[codex] Handle Ctrl-C for non-TTY unified exec (#26734)

## Why

A long-running unified exec process started with `tty: false` could not
be interrupted via `write_stdin`: ordinary non-TTY stdin writes are
rejected once stdin is closed, but an exact U+0003 payload should still
map to a process interrupt. The interrupt should flow through the same
process lifecycle path as a real signal so Codex preserves
process-reported output and exit metadata instead of fabricating a
Ctrl-C exit code or tearing down the session early.

## What Changed

- Add `process/signal` to exec-server with `ProcessSignal::Interrupt`
and an empty response.
- Add a non-consuming `ProcessHandle::signal` path for spawned
processes; on Unix it sends SIGINT to the process group and leaves
terminate/hard-kill unchanged.
- Route non-TTY U+0003 `write_stdin` through `process.signal(...)`
instead of `terminate`, then let the normal post-write collection path
drain output and observe exit.
- Add exec-server coverage where a shell `trap INT` handler prints the
signal and exits with its own code.
- Add unified exec coverage where a `tty: false` process traps SIGINT,
emits output, and exits with its own code.

## Validation

- `just test -p codex-exec-server
exec_process_signal_interrupts_process`
- `just test -p codex-exec-server`
- `just test -p codex-core
write_stdin_ctrl_c_interrupts_non_tty_session`

codex-rs/utils/pty/src/process_group.rs

@@ -118,15 +118,10 @@ pub fn kill_process_group_by_pid(_pid: u32) -> io::Result<()> {
 }
 
 #[cfg(unix)]
-/// Send SIGTERM to a specific process group ID (best-effort).
-///
-/// Returns `Ok(true)` when SIGTERM was delivered to an existing group and
-/// `Ok(false)` when the group no longer exists.
-pub fn terminate_process_group(process_group_id: u32) -> io::Result<bool> {
+fn signal_process_group_id(pgid: libc::pid_t, signal: libc::c_int) -> io::Result<bool> {
     use std::io::ErrorKind;
 
-    let pgid = process_group_id as libc::pid_t;
-    let result = unsafe { libc::killpg(pgid, libc::SIGTERM) };
+    let result = unsafe { libc::killpg(pgid, signal) };
     if result == -1 {
         let err = io::Error::last_os_error();
         if err.kind() == ErrorKind::NotFound || err.raw_os_error() == Some(libc::ESRCH) {
@@ -138,27 +133,37 @@ pub fn terminate_process_group(process_group_id: u32) -> io::Result<bool> {
     Ok(true)
 }
 
+#[cfg(unix)]
+/// Send SIGTERM to a specific process group ID (best-effort).
+///
+/// Returns `Ok(true)` when SIGTERM was delivered to an existing group and
+/// `Ok(false)` when the group no longer exists.
+pub fn terminate_process_group(process_group_id: u32) -> io::Result<bool> {
+    signal_process_group_id(process_group_id as libc::pid_t, libc::SIGTERM)
+}
+
 #[cfg(not(unix))]
 /// No-op on non-Unix platforms.
 pub fn terminate_process_group(_process_group_id: u32) -> io::Result<bool> {
     Ok(false)
 }
 
+#[cfg(unix)]
+/// Send SIGINT to a specific process group ID (best-effort).
+pub fn interrupt_process_group(process_group_id: u32) -> io::Result<()> {
+    signal_process_group_id(process_group_id as libc::pid_t, libc::SIGINT).map(|_| ())
+}
+
+#[cfg(not(unix))]
+/// No-op on non-Unix platforms.
+pub fn interrupt_process_group(_process_group_id: u32) -> io::Result<()> {
+    Ok(())
+}
+
 #[cfg(unix)]
 /// Kill a specific process group ID (best-effort).
 pub fn kill_process_group(process_group_id: u32) -> io::Result<()> {
-    use std::io::ErrorKind;
-
-    let pgid = process_group_id as libc::pid_t;
-    let result = unsafe { libc::killpg(pgid, libc::SIGKILL) };
-    if result == -1 {
-        let err = io::Error::last_os_error();
-        if err.kind() != ErrorKind::NotFound && err.raw_os_error() != Some(libc::ESRCH) {
-            return Err(err);
-        }
-    }
-
-    Ok(())
+    signal_process_group_id(process_group_id as libc::pid_t, libc::SIGKILL).map(|_| ())
 }
 
 #[cfg(not(unix))]