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-runtime/src/acp/rpc.rs

@@ -31,9 +31,10 @@ type Reply = Result<Value, AcpError>;
 type Pending = Arc<Mutex<HashMap<u64, (&'static str, oneshot::Sender<Reply>)>>>;
 
 /// The agent runs as the leader of its own process group; dropping the
-/// connection `SIGKILL`s that group, so the commands the agent started die
-/// with it. A descendant that left the group (`setsid`, `setpgid`) is not
-/// reached.
+/// connection sends that group SIGINT, so the agent can stop the commands
+/// it started, and they get the signal too. Nothing escalates: an agent
+/// that ignores SIGINT keeps running. A descendant that left the group
+/// (`setsid`, `setpgid`) is not reached.
 pub(super) struct Connection {
     child: Child,
     /// The agent's pid, which is its group's id. Read at spawn: a reaped
@@ -66,7 +67,6 @@ impl Connection {
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
             .process_group(0)
-            .kill_on_drop(true)
             .spawn()
             .map_err(|source| AcpError::Spawn {
                 program: command.command.clone(),
@@ -182,7 +182,7 @@ impl Drop for Connection {
             // SAFETY: plain `kill(2)`; `-pgid` targets the agent's own
             // process group, which `process_group(0)` made it lead.
             unsafe {
-                libc::kill(-pgid, libc::SIGKILL);
+                libc::kill(-pgid, libc::SIGINT);
             }
         }
     }