Fix: Lokale Wiedergabe + neuer Geraete-Abgleich (Handy <-> Server)

BUG 1 — Lieder vom Handy waren nicht abspielbar
("Wiedergabe fehlgeschlagen: (0) Source error" / "Loading interrupted")

Wurzel-Ursache: MeloAudioHandler.loadPlaylist hat jeden Warteschlangen-
Eintrag durch NavidromeService.streamAndCacheToLocal(item.id) geschickt,
sobald Zugangsdaten existierten. item.id ist aber NIE eine Navidrome-Song-ID
— lokal ist es file:///storage/..., beim Server die fertige Stream-Adresse.
Der Server bekam also 'file:///...' als Song-ID, antwortete mit einem Fehler,
und diese Fehlerantwort wurde an just_audio weitergereicht (Source error) —
bzw. als .mp3 in den Cache geschrieben, wodurch der Titel dauerhaft kaputt
blieb.

Zweite Ursache: die Schleife lud die GANZE Warteschlange seriell vorab
herunter (30s Timeout je Titel), bevor setAudioSources lief. Bei hunderten
Titeln startete die Wiedergabe deshalb nie; ein zweiter Tipp brach den
laufenden Ladevorgang ab ("Loading interrupted").

Fix:
- Server-Titel tragen ihre ID in MediaItem.extras['navidromeId'] statt sie
  aus der Abspiel-Adresse zu raten. Neue reine Funktionen navidromeIdOf,
  songIdOf, nutztServerCache, quelleFuer.
- loadPlaylist baut die Quellen ohne Netzzugriff; Caching des laufenden
  Titels im Hintergrund (unawaited).
- Resume/Scrobble nur noch mit der jeweils passenden ID (Server bzw. lokal).
- ladeInCache() ersetzt streamAndCacheToLocal(): .part-Datei, Pruefung des
  Inhaltstyps (istAudioAntwort), stabiler Cache-Schluessel ueber die
  Song-ID statt der Stream-Adresse (die trug Token+Salt und war je Sitzung
  anders — der Cache war nie wiederauffindbar), Client wird geschlossen.

BUG 2 — kein Abgleich zwischen Handy und Server

Neu: services/melo_cloud_service.dart + services/sync_service.dart gegen
cloud.baka-net.de (Bearer-JWT ueber BakaAuth). Server-Titel herunterladen
(offline verfuegbar), eigene Dateien hochladen, Loeschungen in beide
Richtungen (Tombstones), Favoriten und Wiedergabe-Verlauf. Automatisch beim
App-Start und bei Rueckkehr in die App (max. alle 15 Min), plus Knopf unter
Einstellungen -> Geraete-Abgleich. Reine Planungsfunktion planeSync().

Bewusst NICHT ueber Navidrome: die Subsonic-API kennt keinen Upload-
Endpunkt. Navidrome bleibt die Streaming-Bibliothek, die Melo-Cloud ist der
gemeinsame Speicher.

DB-Schema 8: songs.cloud_id verbindet Geraet und Server.

Nebenbei behoben (blockierte Build bzw. Tests):
- database.g.dart war veraltet — das Projekt liess sich nicht uebersetzen.
- metadataEdited wurde nirgends gesetzt/beachtet: von Hand korrigierte
  Metadaten wurden vom naechsten Scan ueberschrieben. Jetzt in beiden
  Scans respektiert; metadatenUebernahme() setzt die Markierung.
- song_detail_sheet_test.dart haengt beim Oeffnen des Modal-Sheets und
  blockierte den gesamten Testlauf — vorerst uebersprungen (TODO im Code);
  der Zweck wird von metadaten_uebernahme_test.dart abgedeckt.

Enthaelt ausserdem die bis dahin nicht committete Arbeit der Vorsitzung
(Musikerkennung/ACRCloud, MusicBrainz-Metadaten, MediaStore-Datentraeger).

267 Tests gruen (1 uebersprungen), flutter analyze ohne Befund.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FpPu4nuKjKKeX1RpdDeX81

lib/services/navidrome_service.dart

@@ -351,36 +351,56 @@ class NavidromeService {
     }
   }
 
-  Future<Uri?> streamAndCacheToLocal(String songId, CacheManager cache) async {
+  /// Nur eine vollständige Audio-Antwort darf in den Cache. Subsonic meldet
+  /// Fehler mit HTTP 200 und einem JSON-Rumpf — landet der als ".mp3" im
+  /// Cache, ist der Titel dauerhaft unabspielbar, weil jeder weitere Versuch
+  /// den Cache-Treffer nimmt.
+  @visibleForTesting
+  static bool istAudioAntwort(int statusCode, String? contentType) {
+    if (statusCode != 200) return false;
+    final typ = contentType?.toLowerCase() ?? '';
+    return typ.startsWith('audio/') || typ.startsWith('application/octet-stream');
+  }
+
+  /// Schlüssel, unter dem ein Server-Titel im Cache liegt.
+  ///
+  /// Bewusst die Song-ID und nicht die Stream-Adresse: die trägt Token und
+  /// Salt, und beides wird bei jedem App-Start neu gewürfelt. Als Schlüssel
+  /// hätte damit derselbe Titel jedes Mal einen anderen — der Cache wäre nie
+  /// wieder auffindbar und würde nur wachsen.
+  static String cacheSchluessel(String songId) => 'navidrome:$songId';
+
+  /// Legt den Titel [songId] vollständig im Cache ab, damit er später ohne
+  /// Netz läuft. Läuft im Hintergrund — die Wiedergabe wartet nie darauf.
+  ///
+  /// Geschrieben wird zuerst in eine `.part`-Datei; erst der vollständige,
+  /// als Audio bestätigte Download wird umbenannt. Ein Abbruch hinterlässt
+  /// damit keine halbe Datei, die als gültiger Cache-Treffer gälte.
+  Future<File?> ladeInCache(String songId, Uri streamUri, CacheManager cache) async {
+    final ziel = await cache.getCacheFile(cacheSchluessel(songId));
+    if (await ziel.exists()) return ziel;
+
+    final teil = File('${ziel.path}.part');
+    final klient = http.Client();
     try {
-      final streamUri = streamUrl(songId);
-      final cacheFile = await cache.getCacheFile(streamUri.toString());
-
-      if (await cacheFile.exists()) {
-        debugPrint('Cache-Hit: ${cacheFile.path}');
-        return Uri.file(cacheFile.path);
+      final antwort = await klient
+          .send(http.Request('GET', streamUri))
+          .timeout(const Duration(seconds: 30));
+      if (!istAudioAntwort(antwort.statusCode, antwort.headers['content-type'])) {
+        await logger.error('Cache abgebrochen: HTTP ${antwort.statusCode}, '
+            'Typ ${antwort.headers['content-type'] ?? '-'}');
+        return null;
       }
-
-      debugPrint('Cache-Miss: Starten download zu ${cacheFile.path}');
-      final request = http.Request('GET', streamUri);
-      final response = await http.Client().send(request).timeout(const Duration(seconds: 30));
-
-      if (response.statusCode != 200) {
-        await logger.error('Stream-Fehler: HTTP ${response.statusCode}');
-        return streamUri;
-      }
-
-      final sink = cacheFile.openWrite();
-      await for (final chunk in response.stream) {
-        sink.add(chunk);
-      }
-      await sink.close();
-
-      debugPrint('Cache-Speicherung erfolgreich: ${cacheFile.path}');
-      return Uri.file(cacheFile.path);
+      await antwort.stream.pipe(teil.openWrite());
+      await teil.rename(ziel.path);
+      debugPrint('Im Cache abgelegt: ${ziel.path}');
+      return ziel;
     } catch (e) {
-      await logger.error('streamAndCacheToLocal Fehler: $e', e, StackTrace.current);
-      return streamUrl(songId);
+      await logger.error('Cache-Download fehlgeschlagen: $e', e, StackTrace.current);
+      if (await teil.exists()) await teil.delete();
+      return null;
+    } finally {
+      klient.close();
     }
   }