test(xy): logs --tail and --follow

Fix a deadlock in the log-stream handler that caused all logs
requests to hang: Connection used a single Mutex<JsonFramed> for
both reads and writes, so the serve loop holding the read lock
blocked the spawned notification task from writing.  Split
Connection into separate reader and writer mutexes.

Also fix a response/notification ordering race: the log task now
waits for an explicit ready signal sent by serve after writing the
LOGS response, ensuring notifications never arrive at the client
before their initiating response.

crates/xy-ipc/src/server.rs

@@ -1,33 +1,36 @@
 use crate::envelope::{Incoming, Notification, Response};
-use crate::framing::JsonFramed;
+use crate::framing::{JsonFramedReader, JsonFramedWriter};
 use std::path::Path;
 use std::sync::Arc;
 use tokio::net::{UnixListener, UnixStream};
 use tokio::sync::Mutex;
 
 pub struct Connection {
-    inner: Arc<Mutex<JsonFramed>>,
+    reader: Mutex<JsonFramedReader>,
+    writer: Arc<Mutex<JsonFramedWriter>>,
 }
 
 impl Connection {
     pub fn new(stream: UnixStream) -> Self {
+        let (reader, writer) = crate::framing::split(stream);
         Self {
-            inner: Arc::new(Mutex::new(JsonFramed::new(stream))),
+            reader: Mutex::new(reader),
+            writer: Arc::new(Mutex::new(writer)),
         }
     }
 
     pub async fn read_incoming(&self) -> std::io::Result<Option<Incoming>> {
-        let mut g = self.inner.lock().await;
+        let mut g = self.reader.lock().await;
         g.read::<Incoming>().await
     }
 
     pub async fn write_response(&self, r: &Response) -> std::io::Result<()> {
-        let mut g = self.inner.lock().await;
+        let mut g = self.writer.lock().await;
         g.write(r).await
     }
 
     pub async fn write_notification(&self, n: &Notification) -> std::io::Result<()> {
-        let mut g = self.inner.lock().await;
+        let mut g = self.writer.lock().await;
         g.write(n).await
     }
 }