fix(ios): output muted with A2DP, session lifecycle, mic input issues

Three bugs causing no audio output and no mic input:

1. .voiceChat mode + A2DP = output muted. The .voiceChat mode uses hardware
   AEC/AGC/HPF but requires HFP-compatible routes. A2DP is NOT HFP — iOS
   mutes the output because it can't set up the voice processing pipeline on
   an A2DP route. Fix: use .default mode for Standard+A2DP (no hardware AEC,
   but audio routes correctly). .voiceChat kept for HFP and speaker modes.
   Added info warning in Settings UI for A2DP no-AEC.

2. Session lifecycle broken. stopMicStream() called deactivateAfterStreaming()
   which deactivated the AVAudioSession — but the AudioEngine keeps running for
   remote audio playback, so leaving voice killed all remote audio. And the
   session was never activated when a remote user started talking (only on
   Join Voice), so you couldn't hear anyone before joining voice. Fix:
   - ensureSessionActive() replaces activateForStreaming() — idempotent, called
     on Join Voice AND on .streamStarted (remote user starts talking).
   - stopMicStream() no longer deactivates the session.
   - deactivateSession() called only on disconnect from server.
   - isSessionActive flag tracks state, updated by interruption handler.

3. setPreferredInputNumberOfChannels(1) called for mono — unnecessary (1 is
   the default) and may put the session in a bad state on some devices. Fix:
   only call it when stereo is explicitly selected. Also handle empty input
   port ID (selecting 'Default' in the picker) correctly.

Added comprehensive route logging — after activation, logs the current output
and input route names so issues can be diagnosed from Console.app.

clients/apple/iOS/VoiceCatiOS/AudioSessionManager.swift

@@ -10,6 +10,15 @@ final class AudioSessionManager {
 
     weak var client: VoiceCatClient?
 
+    /// Tracks whether WE activated the session. The session must be active whenever the
+    /// AudioEngine is running (for capture OR playback). Previously, the session was only
+    /// activated when the user joined voice (startMicStream), which meant:
+    ///   - Remote audio was silent if the user hadn't joined voice yet.
+    ///   - Leaving voice (stopMicStream) deactivated the session, killing remote audio.
+    /// Now the session is activated when any audio needs to play (remote stream started OR
+    /// user joins voice) and only deactivated when disconnecting from the server.
+    private var isSessionActive = false
+
     func configure() {
         // Load stored audio routing preferences and apply them before any audio session
         // activation. IOSAudioRouter drives all iOS audio route selection via AVAudioSession;
@@ -26,17 +35,34 @@ final class AudioSessionManager {
             name: AVAudioSession.routeChangeNotification, object: nil)
     }
 
-    func activateForStreaming() throws {
-        // Re-apply the routing configuration before activating, in case the user changed
-        // settings since the last apply. The core (miniaudio) will open whatever route
-        // AVAudioSession has established.
+    /// Activate the AVAudioSession if not already active. Call before any audio I/O:
+    /// when the user joins voice, or when a remote stream starts (so playback works even
+    /// before the user has joined voice). Idempotent — safe to call multiple times.
+    func ensureSessionActive() throws {
+        guard !isSessionActive else {
+            logger.debug("ensureSessionActive — already active, skipping")
+            return
+        }
         IOSAudioRouter.shared.applyConfiguration()
         try AVAudioSession.sharedInstance().setActive(true, options: [])
+        isSessionActive = true
+        let route = AVAudioSession.sharedInstance().currentRoute
+        let outputNames = route.outputs.map { $0.portName }.joined(separator: ", ")
+        let inputNames = route.inputs.map { $0.portName }.joined(separator: ", ")
+        logger.info("session activated — outputs: [\(outputNames)], inputs: [\(inputNames)]")
     }
 
-    func deactivateAfterStreaming() {
+    /// Deactivate the AVAudioSession. Call ONLY when disconnecting from the server — not
+    /// when leaving voice (the user may still want to hear remote audio).
+    func deactivateSession() {
+        guard isSessionActive else {
+            logger.debug("deactivateSession — not active, skipping")
+            return
+        }
         try? AVAudioSession.sharedInstance().setActive(false,
             options: .notifyOthersOnDeactivation)
+        isSessionActive = false
+        logger.info("session deactivated")
     }
 
     @objc private func handleInterruption(_ notification: Notification) {
@@ -47,13 +73,21 @@ final class AudioSessionManager {
 
         switch type {
         case .began:
+            logger.info("interruption began — session suspended by system")
+            isSessionActive = false  // system deactivated us
             client?.audioSuspend()
         case .ended:
             let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt ?? 0
             let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
             if options.contains(.shouldResume) {
-                try? AVAudioSession.sharedInstance().setActive(true)
-                client?.audioResume()
+                do {
+                    try AVAudioSession.sharedInstance().setActive(true)
+                    isSessionActive = true
+                    logger.info("interruption ended — session reactivated")
+                    client?.audioResume()
+                } catch {
+                    logger.error("interruption ended — reactivation failed: \(error.localizedDescription)")
+                }
             }
         @unknown default: break
         }