One reader goroutine per voice conn, so a client can send and listen (V-671)

SendRequest and RunPushReceiver each read the conn, so a client that
wanted both raced for every frame. A second listening conn is not the
fix: it never sends a request, so its lastActive never moves and
PushToMostRecent never picks it. mavwaked needs both on one conn.

The reader now owns the socket for the life of the conn. It hands each
Response to whichever SendRequest waits on that id, and each Push to the
handler. SendRequest waits on its own channel, on the conn dying, on its
context, or on a timeout, and forgets its slot on every path that leaves
without an answer. RunPushReceiver just wires the handler and blocks.

Connect opens the conn without sending anything, for a client that must
hold a session before it has spoken.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013ptwopxyo3Z2kwFckHkLvN

internal/voice/voice_test.go

@@ -221,3 +221,113 @@ func TestClientListenModeReceivesPush(t *testing.T) {
 type pushHandlerFunc func(Push)
 
 func (f pushHandlerFunc) OnPush(p Push) { f(p) }
+
+// The whole point of the per-conn reader (V-671): mavwaked speaks utterances
+// and must hear nudges, and the server routes a nudge to the session that
+// spoke most recently. A second listening conn would never be picked, so both
+// directions have to share one conn.
+func TestClientSendsAndListensOnOneConn(t *testing.T) {
+	l := newTestListener(t)
+	sess := NewSessions()
+	h := &stubHandler{}
+	srv := NewServer(l.Addr().String(), h, sess)
+	if err := srv.Listen(); err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	defer func() {
+		_ = srv.Close()
+		waitPort()
+	}()
+	go func() { _ = srv.Serve() }()
+
+	c := Dial(l.Addr().String())
+	defer c.Close()
+
+	got := make(chan audio.Audio, 4)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go func() {
+		_ = c.RunPushReceiver(ctx, pushHandlerFunc(func(p Push) {
+			var ap AudioNudgePush
+			if err := json.Unmarshal(p.Params, &ap); err == nil {
+				got <- ap.Audio
+			}
+		}))
+	}()
+
+	for i := 0; i < 100 && sess.Active() < 1; i++ {
+		time.Sleep(10 * time.Millisecond)
+	}
+	if sess.Active() != 1 {
+		t.Fatalf("active sessions = %d, want exactly 1", sess.Active())
+	}
+
+	// A round-trip while the receiver is running. Before the reader owned the
+	// conn, this and the receiver raced for every frame.
+	resp, err := c.PushToTalk(context.Background(), audio.Audio{Format: audio.PCM16kMono, Bytes: []byte("hello")}, "ru")
+	if err != nil {
+		t.Fatalf("PushToTalk with a receiver running: %v", err)
+	}
+	if resp.ReplyText != "got it" {
+		t.Fatalf("ReplyText = %q, want %q", resp.ReplyText, "got it")
+	}
+
+	// And the nudge still arrives, on the session that just spoke.
+	err = sess.PushToMostRecent(context.Background(), AudioNudgePush{
+		RuleName: "after-speaking",
+		Audio:    audio.Audio{Format: audio.PCM16kMono, Bytes: []byte("proactive")},
+	})
+	if err != nil {
+		t.Fatalf("PushToMostRecent: %v", err)
+	}
+	select {
+	case a := <-got:
+		if string(a.Bytes) != "proactive" {
+			t.Fatalf("received %q, want the nudge audio", string(a.Bytes))
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("nudge never reached the handler after the client had spoken")
+	}
+}
+
+// A request abandoned by its context must not leave its slot behind, or a
+// long-running client leaks one channel per timeout.
+func TestClientForgetsAbandonedRequests(t *testing.T) {
+	l := newTestListener(t)
+	sess := NewSessions()
+	srv := NewServer(l.Addr().String(), &blockingHandler{}, sess)
+	if err := srv.Listen(); err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	defer func() {
+		_ = srv.Close()
+		waitPort()
+	}()
+	go func() { _ = srv.Serve() }()
+
+	c := Dial(l.Addr().String())
+	defer c.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+	_, err := c.PushToTalk(ctx, audio.Audio{Format: audio.PCM16kMono, Bytes: []byte("x")}, "ru")
+	if err == nil {
+		t.Fatal("expected the round-trip to fail on its context")
+	}
+
+	c.mu.Lock()
+	n := len(c.pending)
+	c.mu.Unlock()
+	if n != 0 {
+		t.Fatalf("pending = %d after an abandoned request, want 0", n)
+	}
+}
+
+// blockingHandler never answers, so the client's context is what ends the
+// round-trip.
+type blockingHandler struct{}
+
+func (blockingHandler) HandlePushToTalk(ctx context.Context, _ PushToTalkReq, _ uint64) (PushToTalkResp, error) {
+	<-ctx.Done()
+	return PushToTalkResp{}, ctx.Err()
+}