fix(pulseaudio): suppress disconnect error during Stream::drop teardown

The play_all driver thread surfaces ClientError::Disconnected when the
reactor drops the source's eof_tx — which happens not only on real
server disconnect but also as a *direct consequence* of Stream::drop
queueing DeletePlaybackStream and the server processing it. The error
callback then fires "PulseAudio client disconnected" on every clean
teardown, despite the connection being healthy.

Check the cancel flag in the play_all spawn before emit_error,
mirroring the latency thread's existing pre-poll cancel check. After a
clean Stream::drop the cancel flag is already set when play_all
unblocks, so the spurious notification is silenced; real disconnects
(reactor exits, socket closed) leave the flag clear and still surface
through the user's error_callback.

Author: knz

CHANGELOG.md

@@ -151,6 +151,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   the driver thread and release the stream, then joins the worker threads
   so the delete actually reaches the server before the process exits
   (#1188).
+- **PulseAudio**: Suppress spurious `StreamInvalidated` ("PulseAudio client
+  disconnected") error callbacks during cleanup. When `Stream::drop` queues
+  the delete, the reactor drops the source's `eof_tx` and the `play_all`
+  driver thread surfaces `ClientError::Disconnected` — even though the
+  server is fine. The driver-thread spawn now checks the cancel flag before
+  emitting the error, mirroring the latency thread's existing behaviour.
 - **JACK**: Port registration failure now fails stream creation instead of silently failing.
 - **JACK**: `activate_async()` failure now returns an error instead of panicking.
 - **JACK**: Sample rate is now validated against the live JACK server at stream creation time.

src/host/pulseaudio/stream.rs

@@ -245,9 +245,18 @@ impl Stream {
         // when the stream is stopped by the user.
         let stream_clone = stream.clone();
         let error_callback_clone = error_callback.clone();
+        let cancel_driver = handle.cancel.clone();
         let driver_handle = std::thread::spawn(move || {
             if let Err(e) = block_on(stream_clone.play_all()) {
-                emit_error(&error_callback_clone, Error::from(e));
+                // Stream::drop sets the cancel flag and then queues
+                // DeletePlaybackStream, which makes the reactor drop the
+                // source's eof_tx and surfaces here as ClientError::Disconnected.
+                // That is teardown noise, not a real error — suppress
+                // emit_error in the cancel case. The latency thread already
+                // does the equivalent check before each timing_info poll.
+                if !cancel_driver.load(atomic::Ordering::Relaxed) {
+                    emit_error(&error_callback_clone, Error::from(e));
+                }
             }
         });