feat: Projekt Scanner integrieren, Whisper in die Einstellungen

Der eigenstaendige Projekt Scanner zieht komplett ins CRM ein und laeuft
parallel zur bestehenden App weiter - jede geteilte Ressource ist verdoppelt
statt geteilt, damit die alte Installation unberuehrt bleibt:

- eigene Datenbank perinco_scanner, legt sich beim Start selbst an
- eigener SCANNER_ENCRYPTION_KEY, eigenes Upload-Verzeichnis
- eigener Scheduler mit Zeitversatz, damit nicht beide Instanzen gleichzeitig
  mit denselben Portal-Cookies scrapen (Rate-Limits, CAPTCHA, doppelter RAM)
- Sperre gegen ueberlappende Laeufe: Scheduler und "Jetzt scannen" teilen sie,
  ein zweiter Aufruf bekommt 409 statt doppelter OpenAI-Kosten

Backend unter /api/scanner hinter der CRM-Anmeldung; die HTTP-Basic-Auth des
Originals entfaellt. CV-PDFs kommen als Stream mit Token statt aus einem
statischen Verzeichnis. Bestandsdaten holt "npm run scanner:import" aus der
alten Datenbank, ohne sie zu veraendern.

Oberflaeche in Tailwind und CI-Farben neu gebaut: Menuepunkt Scanner mit
aufklappbaren Unterpunkten, Einstellungen als eigener Reiter.

Whisper hat keinen eigenen Menuepunkt mehr, sondern ist ein Reiter in den
Einstellungen. Damit diese Geraeteeinstellung jeder Rolle offensteht, sind die
Einstellungen jetzt fuer alle sichtbar - welche Reiter erscheinen, entscheidet
die Rolle.

Ausserdem: kein festes Admin-Passwort mehr im Quelltext, playwright exakt auf
1.60.0 gepinnt (nutzt den vorhandenen Chromium-Build des Servers), technische
Dokumentation mit Funktionszeichnungen unter docs/.

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

src/lib/dictation.tsx

@@ -0,0 +1,142 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useWhisper } from './whisper';
+
+/**
+ * Aufnahme fuer das Diktat. Die Erkennung selbst macht der Whisper-Worker im
+ * Browser (siehe whisper.tsx) - hier geht es nur um Mikrofon, Dauer und das
+ * Weiterreichen der Aufnahme.
+ */
+
+/** Erstes Format, das der Browser aufnehmen kann. */
+function pickMimeType(): string {
+  const candidates = ['audio/webm', 'audio/ogg', 'audio/mp4'];
+  for (const type of candidates) {
+    if (MediaRecorder.isTypeSupported?.(type)) return type;
+  }
+  return '';
+}
+
+type RecorderState = 'idle' | 'recording' | 'transcribing';
+
+interface UseRecorderResult {
+  state: RecorderState;
+  /** Laufende Aufnahmedauer in Sekunden. */
+  seconds: number;
+  start: () => Promise<void>;
+  stop: () => void;
+  cancel: () => void;
+}
+
+export function useRecorder(
+  onText: (text: string) => void,
+  onError: (message: string) => void
+): UseRecorderResult {
+  const { transcribe, status } = useWhisper();
+  const [state, setState] = useState<RecorderState>('idle');
+  const [seconds, setSeconds] = useState(0);
+
+  const recorderRef = useRef<MediaRecorder | null>(null);
+  const chunksRef = useRef<Blob[]>([]);
+  const streamRef = useRef<MediaStream | null>(null);
+  const timerRef = useRef<number | null>(null);
+  const discardRef = useRef(false);
+
+  const cleanup = useCallback(() => {
+    if (timerRef.current !== null) {
+      window.clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    // Mikrofon freigeben, sonst bleibt die Aufnahmeanzeige des Browsers stehen.
+    streamRef.current?.getTracks().forEach((track) => track.stop());
+    streamRef.current = null;
+    recorderRef.current = null;
+    chunksRef.current = [];
+    setSeconds(0);
+  }, []);
+
+  useEffect(() => cleanup, [cleanup]);
+
+  const start = useCallback(async () => {
+    if (state !== 'idle') return;
+    if (status !== 'ready') {
+      onError('Das Spracherkennungsmodell ist noch nicht geladen.');
+      return;
+    }
+    discardRef.current = false;
+
+    let stream: MediaStream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    } catch (err) {
+      const name = (err as DOMException)?.name;
+      onError(
+        name === 'NotAllowedError'
+          ? 'Kein Zugriff aufs Mikrofon. Bitte im Browser erlauben.'
+          : name === 'NotFoundError'
+            ? 'Es wurde kein Mikrofon gefunden.'
+            : 'Die Aufnahme konnte nicht gestartet werden.'
+      );
+      return;
+    }
+
+    const mimeType = pickMimeType();
+    let recorder: MediaRecorder;
+    try {
+      recorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined);
+    } catch {
+      stream.getTracks().forEach((track) => track.stop());
+      onError('Dieser Browser kann kein passendes Audioformat aufnehmen.');
+      return;
+    }
+
+    streamRef.current = stream;
+    recorderRef.current = recorder;
+    chunksRef.current = [];
+
+    recorder.ondataavailable = (event) => {
+      if (event.data.size > 0) chunksRef.current.push(event.data);
+    };
+
+    recorder.onstop = async () => {
+      const blob = new Blob(chunksRef.current, { type: recorder.mimeType || 'audio/webm' });
+      cleanup();
+
+      if (discardRef.current) {
+        setState('idle');
+        return;
+      }
+      if (blob.size < 1024) {
+        setState('idle');
+        onError('Die Aufnahme war zu kurz.');
+        return;
+      }
+
+      setState('transcribing');
+      try {
+        const { text } = await transcribe(blob);
+        if (text) onText(text);
+        else onError('Es war nichts Verstaendliches zu hoeren.');
+      } catch (err) {
+        onError(err instanceof Error ? err.message : 'Die Erkennung ist fehlgeschlagen.');
+      } finally {
+        setState('idle');
+      }
+    };
+
+    recorder.start();
+    setState('recording');
+    setSeconds(0);
+    timerRef.current = window.setInterval(() => setSeconds((value) => value + 1), 1000);
+  }, [state, status, cleanup, onError, onText, transcribe]);
+
+  const stop = useCallback(() => {
+    if (recorderRef.current?.state === 'recording') recorderRef.current.stop();
+  }, []);
+
+  const cancel = useCallback(() => {
+    discardRef.current = true;
+    stop();
+  }, [stop]);
+
+  return { state, seconds, start, stop, cancel };
+}