new: Add a from-scratch ProcessRegistry alongside the existing one

[milesj]

Summary

Adds a second-generation ProcessRegistry under crates/process/src/registry/, exposed as the starbase_process::registry module so it sits next to the current registry without a name collision. It is split by concern: options, child (tracked child types), event, state (shared state and the shutdown algorithm), tasks (reaper and shutdown coordinator), tree (process-tree enumeration per platform), cache, and process_registry (the public type). The existing registry and the exec_* methods on Command are untouched; swapping them over (and then removing the old file) is a follow-up once the API is agreed on.

What the new registry does

• Tracking: spawn a tokio Command (recording its command line) or track an existing Child. Children have a Running/Exited state and stay tracked until released, so a forced shutdown can still stop readers draining pipes held open by descendants.
• Automatic cleanup: a reaper task detects exits via SIGCHLD on Unix, with an interval sweep as a safety net (and as the mechanism on Windows). Dropping a running child's original handle kills it as a cancellation (kill_on_drop); dropping an exited handle releases it.
• Signals and events: OS termination signals feed a broadcast channel that a coordinator task turns into shutdowns. A ProcessEvent stream covers tracked/exited/released/signal/shutdown started/forced/finished.
• Process trees: signal_descendants snapshots each child's descendants before signalling, so a shell wrapper's work is reached too. Linux reads /proc, macOS uses proc_listchildpids, other Unixes fall back to ps, Windows uses a ToolHelp snapshot + OpenProcess/TerminateProcess.
• Shutdown: shutdown(signal) signals every running child, waits up to shutdown_threshold, force kills the rest, stops all output readers, and returns once everything has exited. A second signal escalates immediately. Routes through the coordinator when started, runs inline when stopped.
• Start/stop/restart: shared state lives in an Arc borrowed by the tasks, so tasks can be moved between runtimes without losing tracked children, cache, or subscribers. Constructing outside a runtime leaves it stopped until start.
• Singleton or not: instance/register(options)/try_instance, or new/with_options for independent registries.
• Output cache: LRU cache plus exec_cached, which coalesces concurrent identical runs into one execution. Failures are not cached.

Supporting changes

• SharedChild::try_wait (public): lets the reaper check for exit without tokio's wait, which closes stdin.
• Race fix in SharedChild::wait: reaping a tokio Child via try_wait drops tokio's per-child SIGCHLD listener, so a task already inside wait lost its waker and hung. Found via stress testing; the existing kill_with_signal path has the same latent race. wait now also wakes on an exit recorded by try_wait.
• Two extra windows-sys features for the ToolHelp snapshot.

Testing

• 35 new tests in tests/registry_test.rs (Unix), covering lifecycle, tracking, reaping without closing stdin, drop semantics, single and tree signalling, graceful/forced/inline shutdown, events, and cache coalescing. Passed 20/20 stress runs after the race fix.
• All existing crate suites pass; clippy (-D warnings), rustfmt, and rustdoc (-D warnings) are clean; the crate type-checks for x86_64-pc-windows-msvc. Linux was not compile-checked locally.
• Reviewer note: exec_command_test::cancellation::force_kill_unblocks_continuous_input_with_inherited_stdin flakes roughly 1 in 10 runs on master as well (missing marker file); it is unrelated to this change.

🤖 Generated with Claude Code