feat(app-server): thread/unsubscribe API (#10954)

Adds a new v2 app-server API for a client to be able to unsubscribe to a
thread:
- New RPC method: `thread/unsubscribe`
- New server notification: `thread/closed`

Today clients can start/resume/archive threads, but there wasn’t a way
to explicitly unload a live thread from memory without archiving it.
With `thread/unsubscribe`, a client can indicate it is no longer
actively working with a live Thread. If this is the only client
subscribed to that given thread, the thread will be automatically closed
by app-server, at which point the server will send `thread/closed` and
`thread/status/changed` with `status: notLoaded` notifications.

This gives clients a way to prevent long-running app-server processes
from accumulating too many thread (and related) objects in memory.

Closed threads will also be removed from `thread/loaded/list`.

codex-rs/app-server/src/thread_state.rs

@@ -207,6 +207,50 @@ impl ThreadStateManager {
         });
     }
 
+    pub(crate) async fn unsubscribe_connection_from_thread(
+        &mut self,
+        thread_id: ThreadId,
+        connection_id: ConnectionId,
+    ) -> bool {
+        let Some(thread_state) = self.thread_states.get(&thread_id) else {
+            return false;
+        };
+
+        if !self
+            .thread_ids_by_connection
+            .get(&connection_id)
+            .is_some_and(|thread_ids| thread_ids.contains(&thread_id))
+        {
+            return false;
+        }
+
+        if let Some(thread_ids) = self.thread_ids_by_connection.get_mut(&connection_id) {
+            thread_ids.remove(&thread_id);
+            if thread_ids.is_empty() {
+                self.thread_ids_by_connection.remove(&connection_id);
+            }
+        }
+
+        self.subscription_state_by_id.retain(|_, state| {
+            !(state.thread_id == thread_id && state.connection_id == connection_id)
+        });
+
+        let mut thread_state = thread_state.lock().await;
+        thread_state.remove_connection(connection_id);
+        true
+    }
+
+    pub(crate) async fn has_subscribers(&self, thread_id: ThreadId) -> bool {
+        let Some(thread_state) = self.thread_states.get(&thread_id) else {
+            return false;
+        };
+        !thread_state
+            .lock()
+            .await
+            .subscribed_connection_ids()
+            .is_empty()
+    }
+
     pub(crate) async fn set_listener(
         &mut self,
         subscription_id: Uuid,