SMB: drop dead acquire_client + LoggedClientGuard

`acquire_client` had its sole hot-path caller removed in `efb15479` —
the streaming write path now drives on an owned `Connection` clone via
smb2 0.9's owned `FileWriter`. Nothing else called it. `LoggedClientGuard`
existed only to instrument that one method's release point, so it goes
with it.

`clone_session` keeps its ticketed `client-mutex:` debug logs: that's
the one remaining lock acquire on the SMB session and a useful future
diagnostic. The mutex is held for microseconds per call now (just to
clone the underlying `Arc<Connection>`), so the logs sit at `debug`
where they fire only when explicitly enabled.

Also updates the colocated CLAUDE.md and the historical comment in
`write_from_stream` to point at the regression test that pins the
no-deadlock shape, not the deleted Phase C QNAP test.

Author: vdavid

apps/desktop/src-tauri/src/file_system/volume/CLAUDE.md

@@ -411,7 +411,7 @@ spawned detached task. This is safe because the stream always lives in an async
 **Why**: SMB servers return NFC-normalized filenames. macOS filesystem paths use NFD. The watcher NFD-normalizes filenames before constructing display paths used for cache lookups.
 
 **Gotcha (no longer applicable as of smb2 0.9)**: SMB write streaming fallback used to hold the client mutex for the whole upload
-**Why**: Historically `FileWriter<'a>` borrowed `&'a mut Connection` from the `SmbClient`, so `write_from_stream` had to hold the client mutex for the duration of the streaming write. Under sustained concurrent pressure on QNAP this two-phase pattern (brief `clone_session` fast-path probe → drop → long `acquire_client` for the streaming fallback) deadlocked: Phase C `smb_integration_phase_c_deadlock_repro_qnap` reproduced it reliably. smb2 0.9 rebuilt `FileWriter` to own its `Connection` and `Arc<Tree>`, removing the borrow. See the new Decision below (`write_from_stream` uses a cloned Connection + Arc<Tree>) for the current design.
+**Why**: Historically `FileWriter<'a>` borrowed `&'a mut Connection` from the `SmbClient`, so `write_from_stream` had to hold the client mutex for the duration of the streaming write. Under sustained concurrent pressure this two-phase pattern (brief `clone_session` fast-path probe → drop → long mutex-guarded streaming fallback) deadlocked. smb2 0.9 rebuilt `FileWriter` to own its `Connection` and `Arc<Tree>`, removing the borrow. The regression is pinned by `smb_integration_concurrent_streaming_writes_no_deadlock`. See the new Decision below (`write_from_stream` uses a cloned Connection + Arc<Tree>) for the current design.
 
 **Decision**: `write_from_stream` uses a cloned `Connection` + `Arc<Tree>` via smb2 0.9's owned `FileWriter`
 **Why**: smb2 0.9 made `FileWriter` own its `Connection` (cheap `Arc::clone`) and `Arc<Tree>` instead of borrowing `&'a mut Connection`. `write_from_stream` now calls `clone_session` once up front and drives both the compound fast-path AND the streaming fallback on the same owned `Connection` clone. The client mutex is held only for the few microseconds of `clone_session()`, never across I/O. The previous shape — fast-path on a clone, then drop and re-acquire the client for the streaming fallback — was the deadlock reproducer in Phase C against QNAP. The architectural property we get for free: N concurrent streaming writes on one `SmbVolume` pipeline N WRITE chains over a single SMB session, multiplexed by `MessageId` in smb2's receiver task. No external locking, no mutex contention on the hot copy path.

apps/desktop/src-tauri/src/file_system/volume/smb.rs

@@ -94,51 +94,8 @@ impl ConnectionState {
     }
 }
 
-// ── Client-mutex instrumentation ────────────────────────────────────
-//
-// Pure observability around the `client` mutex on `SmbVolume`. Helps
-// diagnose deadlocks where the lock appears to be held indefinitely by
-// an unknown task. Every acquire allocates a process-global ticket and
-// emits three debug logs: `waiting`, `acquired`, and `released`. Grep
-// one log file for `client-mutex:` to reconstruct who holds the lock,
-// who's queued behind them, and how long each hold lasts.
-
 static CLIENT_LOCK_TICKET: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
 
-/// RAII wrapper around the client `MutexGuard` that logs on Drop so the
-/// release event is captured even if the caller returns early. Transparent
-/// to callers via `Deref` / `DerefMut` over `Option<SmbClient>`.
-struct LoggedClientGuard<'a> {
-    inner: tokio::sync::MutexGuard<'a, Option<SmbClient>>,
-    ticket: u64,
-    caller: &'static str,
-    acquired_at: std::time::Instant,
-}
-
-impl<'a> std::ops::Deref for LoggedClientGuard<'a> {
-    type Target = Option<SmbClient>;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<'a> std::ops::DerefMut for LoggedClientGuard<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
-impl<'a> Drop for LoggedClientGuard<'a> {
-    fn drop(&mut self) {
-        log::debug!(
-            "client-mutex: released ticket={} caller={} held_for={:?}",
-            self.ticket,
-            self.caller,
-            self.acquired_at.elapsed()
-        );
-    }
-}
-
 // ── Type mapping helpers ────────────────────────────────────────────
 
 /// Converts an `smb2::FileTime` to seconds since the Unix epoch, matching
@@ -508,53 +465,6 @@ impl SmbVolume {
         }
     }
 
-    /// Acquires the client mutex and returns a guard over the `Option<SmbClient>`.
-    /// Checks connection state first, then verifies the client is present.
-    ///
-    /// **No longer called from any hot path.** Every read and write goes
-    /// through `clone_session` and drives its op on an owned
-    /// `Connection` clone (cheap `Arc::clone`) — including the streaming
-    /// write path since smb2 0.9's owned `FileWriter`. This method is
-    /// kept for now in case future reconnect / diagnostic paths need a
-    /// guarded `&mut SmbClient` (the `SmbClient` itself is `!Clone`).
-    /// Candidate for removal once we're confident no such caller is
-    /// coming back; see also `LoggedClientGuard`.
-    #[allow(dead_code)]
-    async fn acquire_client(&self) -> Result<LoggedClientGuard<'_>, VolumeError> {
-        self.check_connection()?;
-        let ticket = CLIENT_LOCK_TICKET.fetch_add(1, Ordering::Relaxed);
-        let start = std::time::Instant::now();
-        log::debug!(
-            "client-mutex: waiting ticket={} caller=acquire_client share={}",
-            ticket,
-            self.share_name
-        );
-        let guard = self.client.lock().await;
-        log::debug!(
-            "client-mutex: acquired ticket={} caller=acquire_client share={} waited={:?}",
-            ticket,
-            self.share_name,
-            start.elapsed()
-        );
-        if guard.is_none() {
-            // Drop the unwrapped guard explicitly so the released-log
-            // doesn't fire for a "no-op" acquire that immediately bails.
-            drop(guard);
-            log::debug!(
-                "client-mutex: released ticket={} caller=acquire_client held_for={:?} (no-session-bail)",
-                ticket,
-                start.elapsed()
-            );
-            return Err(VolumeError::DeviceDisconnected("SMB session not available".to_string()));
-        }
-        Ok(LoggedClientGuard {
-            inner: guard,
-            ticket,
-            caller: "acquire_client",
-            acquired_at: start,
-        })
-    }
-
     /// Reads out a clone of `Arc<Tree>`. Cheap (`Arc::clone`).
     async fn tree_arc(&self) -> Result<Arc<Tree>, VolumeError> {
         self.check_connection()?;
@@ -1821,10 +1731,12 @@ impl Volume for SmbVolume {
         // receiver task multiplexes responses by `MessageId`.
         //
         // This collapses the historical two-phase pattern (brief
-        // `clone_session` for the fast-path → drop → long `acquire_client`
-        // for the streaming fallback) into a single-phase clone. The old
-        // shape deadlocked under sustained concurrent pressure on QNAP
-        // (Phase C `smb_integration_phase_c_deadlock_repro_qnap`).
+        // `clone_session` for the fast-path → drop → long
+        // session-mutex hold for the streaming fallback) into a single
+        // clone. The old shape deadlocked under sustained concurrent
+        // pressure; the regression test
+        // `smb_integration_concurrent_streaming_writes_no_deadlock`
+        // pins this shape.
         Box::pin(async move {
             let smb_path = self.to_smb_path(dest);