subagents, ACP: stop with SIGINT only, so claude ends its own tool commands

claude's Bash tool starts every command in a new session, so a signal to
claude's process group never reaches it. claude stops those commands
itself when SIGINT makes it shut down. A SIGKILL leaves them running,
re-parented to init. Per the ruling on #4999, every stop is SIGINT and
nothing escalates.

- Subagent `interrupt` always sends SIGINT. The `force` argument is gone
  from the MCP tool and from `session::interrupt`. A caller that still
  sends `force: true` gets SIGINT; the argument is ignored.
- `interrupt` used to free the session name before it signalled, so a
  `continue` could start a second claude on the session while the first
  was still exiting. The `running` map now holds a three-state `Slot`
  (starting, running, stopping). An interrupted claude turn is
  `Stopping` until the turn task's own `finish_turn` clears it. `status`
  says "stopping", and `start`/`continue` on that name are refused.
  `interrupt` still returns at once. The ACP arm is unchanged: its name
  is freed when `session/cancel` is sent.
- ACP `Connection` drop sends its process group SIGINT, not SIGKILL, and
  the spawn no longer sets tokio's `kill_on_drop`, which SIGKILLed the
  leader after the `Drop` body. The test fixture's background grandchild
  resets SIGINT to default, since `&` starts it ignored.

Tests: a fake claude that records SIGINT, interrupted, fails with
`cancel(true)` (the old `force: true` path). An interrupted fake claude
that keeps running keeps its name claimed and `continue` is refused,
which fails when the slot is freed before the signal. A fake ACP agent
that records SIGINT, dropped, fails with SIGKILL in `Drop`, and also with
SIGINT in `Drop` but `kill_on_drop(true)` left in place.

Not changed: hive-claude's idle watchdog (still SIGKILL, separate
hive-claude change), the units' `KillSignal`, `machinectl kill`, and the
login helper.

hive-subagent-mcp/src/mcp.rs

@@ -187,10 +187,6 @@ struct StatusArgs {
 struct InterruptArgs {
     /// The running session's name to signal.
     name: String,
-    /// `true` sends SIGKILL immediately; `false` (default) sends SIGINT,
-    /// letting claude shut down cleanly if it's already mid-response.
-    #[serde(default)]
-    force: bool,
 }
 
 #[derive(Clone)]
@@ -276,11 +272,13 @@ impl SubagentMcp {
             re-prompted toward it afterwards, and `continue` is what restarts it. Only works \
             once it's actually running — a `start`/`continue` still in its brief window before \
             the process is confirmed spawned refuses interrupt too (nothing to signal yet; \
-            retry shortly), same as a name with nothing tracked at all. `force: true` for \
-            SIGKILL, otherwise SIGINT."
+            retry shortly), same as a name with nothing tracked at all. On claude it sends \
+            SIGINT, which claude answers by stopping the commands it started and exiting; \
+            nothing escalates past it. Returns at once; the name stays claimed until claude \
+            has exited, and `status` says `stopping` until then."
     )]
     fn interrupt(&self, Parameters(args): Parameters<InterruptArgs>) -> String {
-        match session::interrupt(&self.state, &args.name, args.force) {
+        match session::interrupt(&self.state, &args.name) {
             Ok(msg) => msg,
             Err(e) => format!("interrupt error: {e:#}"),
         }