feat: Bug-Runde + 5 App/Diagnostic-Features

Bugs:
- App Mute-/Auto-Playback: onMessage-Closure hielt stale ttsDeviceEnabled/
  ttsMuted → Mute wurde ignoriert + AsyncStorage-Load kam nicht durch.
  Fix via ttsCanPlayRef (live gespiegelt) statt Closure-Variablen.
- App Zombie-Recording: toggleWakeWord hat die laufende Aufnahme nicht
  gestoppt → audioService.recordingState blieb 'recording' → normaler
  Aufnahme-Button wirkungslos. Fix: await stopRecording() vor stop().
- Porcupine robuster: BuiltInKeywords-Enum Mapping mit String-Fallback,
  errorCallback fuer Runtime-Crashes (state zurueck auf off statt
  App-Crash), mehr Logging damit man beim naechsten Issue debuggen kann.

App-Features:
- MessageText Komponente: Text ist durchgehend selektierbar, erkennt
  URLs (http/https), E-Mails, Telefonnummern und macht sie anklickbar
  (oeffnet Browser / Mail-App / Android-Dialer via Linking).
- TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings ->
  "Sprechgeschwindigkeit", 0.5-2.0 in 0.1-Schritten, Default 1.0).
  Wird als speed-Param an die F5-TTS-Bridge durchgereicht.

Bridge-Durchreichen:
- ChatScreen: speed aus AsyncStorage via ttsSpeedRef, an chat/audio/
  tts_request mitgeschickt
- aria-bridge: _next_speed_override wie voice_override, an xtts_request
  weitergereicht
- f5tts-bridge: speed-Param an F5TTS.infer() durchgereicht

Diagnostic-Feature:
- Voice-Preview-Button (Play-Icon) vor dem Delete-X in der Stimmen-Liste
- Modal mit Textfeld (Default-Beispieltext wird bei jedem Oeffnen neu
  gesetzt) und Play-Button
- Server sammelt audio_pcm Frames der Preview-Anfrage, baut WAV,
  schickt base64 zurueck, Browser spielt im <audio>-Tag ab
- 60s Timeout-Safety-Net

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

xtts/f5tts/bridge.py

@@ -237,7 +237,8 @@ class F5Runner:
         else:
             logger.info("F5-TTS Live-Config: cfg_strength=%.2f nfe=%d", new_cfg, new_nfe)
 
-    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
+    def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str,
+                        speed: float = 1.0) -> tuple[np.ndarray, int]:
         wav, sr, _ = self.model.infer(
             ref_file=ref_wav,
             ref_text=ref_text,
@@ -246,6 +247,7 @@ class F5Runner:
             seed=-1,
             cfg_strength=self.cfg_strength,
             nfe_step=self.nfe_step,
+            speed=speed,
         )
         # F5-TTS gibt float32 1D-Array — auf 24kHz sample-rate standard
         if not isinstance(wav, np.ndarray):
@@ -254,10 +256,11 @@ class F5Runner:
             wav = wav.squeeze()
         return wav.astype(np.float32), int(sr)
 
-    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str) -> tuple[np.ndarray, int]:
+    async def synthesize(self, gen_text: str, ref_wav: str, ref_text: str,
+                         speed: float = 1.0) -> tuple[np.ndarray, int]:
         await self.ensure_loaded()
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text)
+        return await loop.run_in_executor(None, self._infer_blocking, gen_text, ref_wav, ref_text, speed)
 
 
 # ── Helpers ─────────────────────────────────────────────────
@@ -421,9 +424,9 @@ _tts_queue: asyncio.Queue[tuple] = asyncio.Queue()
 async def _tts_worker(ws, runner: F5Runner) -> None:
     """Serialisiert Synthesen — GPU kann sonst OOM gehen."""
     while True:
-        text, voice, request_id, message_id, language = await _tts_queue.get()
+        text, voice, request_id, message_id, language, speed = await _tts_queue.get()
         try:
-            await _do_tts(ws, runner, text, voice, request_id, message_id, language)
+            await _do_tts(ws, runner, text, voice, request_id, message_id, language, speed)
         except Exception:
             logger.exception("TTS-Worker Fehler")
         finally:
@@ -431,7 +434,8 @@ async def _tts_worker(ws, runner: F5Runner) -> None:
 
 
 async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
-                  request_id: str, message_id: str, language: str) -> None:
+                  request_id: str, message_id: str, language: str,
+                  speed: float = 1.0) -> None:
     t0 = time.time()
     ref_wav_path, ref_txt_path = voice_paths(voice) if voice else (None, None)
 
@@ -509,7 +513,7 @@ async def _do_tts(ws, runner: F5Runner, text: str, voice: str,
     pcm_sr = TARGET_SR
     for i, sent in enumerate(sentences):
         try:
-            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text)
+            wav, sr = await runner.synthesize(sent, ref_wav_str, ref_text, speed)
             pcm_sr = sr
             pcm_bytes = float_to_pcm16(wav)
             # Erste PCM-Chunk des allerersten Satzes bekommt Fade-In (maskiert
@@ -754,12 +758,19 @@ async def run_loop(runner: F5Runner) -> None:
                         payload = msg.get("payload", {}) or {}
 
                         if mtype == "xtts_request":
+                            try:
+                                speed = float(payload.get("speed") or 1.0)
+                            except (TypeError, ValueError):
+                                speed = 1.0
+                            if not (0.25 <= speed <= 4.0):
+                                speed = 1.0
                             await _tts_queue.put((
                                 payload.get("text", ""),
                                 payload.get("voice", "") or "",
                                 payload.get("requestId", ""),
                                 payload.get("messageId", ""),
                                 payload.get("language", "de"),
+                                speed,
                             ))
                         elif mtype == "voice_upload":
                             asyncio.create_task(handle_voice_upload(ws, payload))