[codex] add process-owned code-mode session client (#30112)

## Summary

- add `ProcessOwnedCodeModeSessionProvider` and logical session
generation/rebinding state
- add the supervised child-process connection, reader/writer tasks, and
driver state machine
- make dropped execute/wait/open callers cancellation-safe with explicit
ownership handoff and durable cleanup
- validate cell/delegate lifecycle state and reject invalid protocol
transitions
- add end-to-end stdio coverage for delegates, cancellation, frame
limits, child loss, stale generations, replacement, and long-lived
sessions

## Why

This final stage exposes the process-owned client only after the wire
protocol, host-safe runtime, and standalone host are independently in
place. Transport failure is fail-stop: the client closes local state,
cancels callbacks, reaps the child, and lazily rebuilds a fresh host
generation rather than transactionally recovering the old connection.

## Stack

This is **4 of 4** in the process-owned code-mode session stack.

- Depends on #30111
- Full stack: #30108 → #30110 → #30111 → this PR

## Validation

- `just test -p codex-code-mode -p codex-code-mode-host` — 86 passed
- `just fix -p codex-code-mode`
- `just fix -p codex-code-mode-host`
- `just bazel-lock-update`
- `just bazel-lock-check`
- `bazel test //codex-rs/code-mode:code-mode-unit-tests
//codex-rs/code-mode-host:code-mode-host-unit-tests
//codex-rs/code-mode-host:code-mode-host-stdio-test
//codex-rs/code-mode-protocol:code-mode-protocol-unit-tests` — 4/4
passed
- `just fmt`

codex-rs/code-mode/src/remote_session_tests.rs

@@ -0,0 +1,52 @@
+use std::sync::Arc;
+
+use codex_code_mode_protocol::CodeModeSessionProvider;
+
+use super::ProcessOwnedCodeModeSession;
+use super::ProcessOwnedCodeModeSessionProvider;
+use crate::NoopCodeModeSessionDelegate;
+
+#[test]
+fn provider_reuses_its_live_process_host() {
+    let provider = ProcessOwnedCodeModeSessionProvider::default();
+
+    let first = provider.process_host();
+    let second = provider.process_host();
+
+    assert!(Arc::ptr_eq(&first, &second));
+}
+
+#[tokio::test]
+async fn provider_reports_host_spawn_failure() {
+    let provider = ProcessOwnedCodeModeSessionProvider::with_host_program(
+        "codex-code-mode-host-does-not-exist".into(),
+    );
+
+    let error = provider
+        .create_session(Arc::new(NoopCodeModeSessionDelegate))
+        .await
+        .err()
+        .expect("session creation should fail");
+
+    assert!(error.contains("failed to spawn code-mode host"));
+}
+
+#[tokio::test]
+async fn shutdown_before_open_does_not_spawn_the_host() {
+    let session = ProcessOwnedCodeModeSession::new();
+
+    session.shutdown().await.expect("shutdown session");
+    let error = session
+        .execute(codex_code_mode_protocol::ExecuteRequest {
+            tool_call_id: "call-1".to_string(),
+            enabled_tools: Vec::new(),
+            source: "text('unreachable')".to_string(),
+            yield_time_ms: None,
+            max_output_tokens: None,
+        })
+        .await
+        .err()
+        .expect("shutdown session should reject execution");
+
+    assert_eq!(error, "code mode session is shutting down");
+}