fix: address CodeRabbit review findings — MPS cache cleanup, MLX unload thread-safety

Two follow-ups from the automated review on this PR:

1. backend/backends/base.py: empty_device_cache() only handled "cuda"
   and "xpu", never "mps" — so once the previous commit enabled MPS for
   the PyTorch Qwen3-TTS/CustomVoice engines, switching model sizes on
   Apple Silicon would leak MPS-cached memory (torch.mps.empty_cache()
   never got called). Added the missing branch.

2. backend/backends/qwen_custom_voice_backend.py: unload_model() had
   its own inline `if torch.cuda.is_available(): torch.cuda.empty_cache()`
   instead of using the shared empty_device_cache() helper — meant it
   never freed MPS memory either, same bug as #1 but duplicated instead
   of shared. Switched to the shared helper (matches pytorch_backend.py's
   existing pattern).

3. backend/backends/mlx_backend.py: load_model_async()'s unload-on-
   model-size-change call went straight to self.unload_model() instead
   of routing through _run_on_mlx_thread like every other MLX call in
   this file (the whole point of the earlier commit in this PR). Fixed
   for consistency with the thread-pinning fix.

Verified on M4: 0.6B -> generate still works post-changes (regression
check), torch.mps.empty_cache() confirmed callable without error in
this environment.

Author: AlexStephenLytton

backend/backends/base.py

@@ -171,17 +171,19 @@ def check_cuda_compatibility() -> tuple[bool, str | None]:
 
 def empty_device_cache(device: str) -> None:
     """
-    Free cached memory on the given device (CUDA or XPU).
+    Free cached memory on the given device (CUDA, XPU, or MPS).
 
-    Backends should call this after unloading models so VRAM is returned
-    to the OS.
+    Backends should call this after unloading models so VRAM/unified
+    memory is returned to the OS.
     """
     import torch
 
     if device == "cuda" and torch.cuda.is_available():
         torch.cuda.empty_cache()
     elif device == "xpu" and hasattr(torch, "xpu"):
         torch.xpu.empty_cache()
+    elif device == "mps" and hasattr(torch, "mps"):
+        torch.mps.empty_cache()
 
 
 def manual_seed(seed: int, device: str) -> None:

backend/backends/mlx_backend.py

@@ -93,9 +93,11 @@ async def load_model_async(self, model_size: Optional[str] = None):
         if self.model is not None and self._current_model_size == model_size:
             return
 
-        # Unload existing model if different size requested
+        # Unload existing model if different size requested — routed
+        # through the same dedicated thread as load/generate so it stays
+        # serialized with any in-flight MLX call (see _run_on_mlx_thread).
         if self.model is not None and self._current_model_size != model_size:
-            self.unload_model()
+            await _run_on_mlx_thread(self.unload_model)
 
         # Run blocking load on the dedicated MLX thread
         await _run_on_mlx_thread(self._load_model_sync, model_size)

backend/backends/qwen_custom_voice_backend.py

@@ -25,6 +25,7 @@
 from .base import (
     is_model_cached,
     get_torch_device,
+    empty_device_cache,
     combine_voice_prompts as _combine_voice_prompts,
     model_load_progress,
 )
@@ -127,8 +128,7 @@ def unload_model(self) -> None:
             self.model = None
             self._current_model_size = None
 
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
+            empty_device_cache(self.device)
 
             logger.info("Qwen CustomVoice unloaded")