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

test/player/queue_quelle_test.dart

@@ -0,0 +1,119 @@
+import 'package:audio_service/audio_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:melo/library/database.dart';
+import 'package:melo/library/song_media.dart';
+import 'package:melo/player/audio_handler.dart';
+import 'package:melo/services/navidrome_service.dart';
+
+Song _lokalerSong() => Song(
+      id: 'uuid-1',
+      path: '/storage/emulated/0/Music/Nightcore.mp3',
+      title: 'No Friends',
+      dateAddedMs: 0,
+      updatedAtMs: 0,
+      deleted: false,
+      playCount: 0,
+      categoriesEdited: false,
+      metadataEdited: false,
+    );
+
+void main() {
+  group('Titel vom Gerät werden nie als Server-Titel behandelt', () {
+    test('ein lokaler Song trägt keine Navidrome-ID', () {
+      expect(navidromeIdOf(songToMediaItem(_lokalerSong())), isNull);
+    });
+
+    test('für einen lokalen Song wird der Server-Cache nicht befragt', () {
+      // Wurzel-Ursache von "Wiedergabe fehlgeschlagen: (0) Source error":
+      // die file://-URI wurde als Navidrome-Song-ID an den Server geschickt.
+      expect(nutztServerCache(songToMediaItem(_lokalerSong())), isFalse);
+    });
+
+    test('ein lokaler Song bringt seine UUID für die lokale Historie mit', () {
+      expect(songIdOf(songToMediaItem(_lokalerSong())), 'uuid-1');
+    });
+
+    test('ein lokaler Song wird direkt von seinem Dateipfad gespielt', () {
+      expect(
+        quelleFuer(songToMediaItem(_lokalerSong())),
+        Uri.file('/storage/emulated/0/Music/Nightcore.mp3'),
+      );
+    });
+  });
+
+  group('Server-Titel', () {
+    final serverTitel = MediaItem(
+      id: 'https://musik.baka-net.de/rest/stream.view?id=abc123',
+      title: 'Serverlied',
+      extras: const {'navidromeId': 'abc123'},
+    );
+
+    test('trägt seine Navidrome-ID getrennt von der Abspiel-URI', () {
+      expect(navidromeIdOf(serverTitel), 'abc123');
+      expect(songIdOf(serverTitel), isNull);
+    });
+
+    test('darf im Server-Cache nachgesehen werden', () {
+      expect(nutztServerCache(serverTitel), isTrue);
+    });
+
+    test('läuft ohne Cache-Treffer direkt vom Stream', () {
+      expect(quelleFuer(serverTitel), Uri.parse(serverTitel.id));
+    });
+
+    test('läuft mit Cache-Treffer aus der lokalen Datei', () {
+      expect(
+        quelleFuer(serverTitel, cacheTreffer: '/cache/abc.mp3'),
+        Uri.file('/cache/abc.mp3'),
+      );
+    });
+  });
+
+  group('NavidromeService.cacheSchluessel', () {
+    test('hängt nur an der Song-ID, nicht an der Stream-Adresse', () {
+      // Die Stream-Adresse trägt Token und Salt und ist bei jedem App-Start
+      // eine andere — als Cache-Schlüssel wäre ein Titel nie wiederzufinden.
+      expect(NavidromeService.cacheSchluessel('abc123'),
+          NavidromeService.cacheSchluessel('abc123'));
+      expect(NavidromeService.cacheSchluessel('abc123'),
+          isNot(NavidromeService.cacheSchluessel('xyz789')));
+    });
+  });
+
+  group('NavidromeService.istAudioAntwort', () {
+    test('Subsonic-Fehler kommt mit HTTP 200 und JSON — nie in den Cache', () {
+      // Genau diese Antwort landete als ".mp3" im Cache und machte den Titel
+      // dauerhaft unabspielbar.
+      expect(
+        NavidromeService.istAudioAntwort(200, 'application/json'),
+        isFalse,
+      );
+    });
+
+    test('HTML-Fehlerseite ist keine Musik', () {
+      expect(
+        NavidromeService.istAudioAntwort(200, 'text/html; charset=utf-8'),
+        isFalse,
+      );
+    });
+
+    test('fehlender Content-Type ist keine Musik', () {
+      expect(NavidromeService.istAudioAntwort(200, null), isFalse);
+    });
+
+    test('HTTP 404 ist keine Musik', () {
+      expect(NavidromeService.istAudioAntwort(404, 'audio/mpeg'), isFalse);
+    });
+
+    test('audio/mpeg darf in den Cache', () {
+      expect(NavidromeService.istAudioAntwort(200, 'audio/mpeg'), isTrue);
+    });
+
+    test('application/octet-stream darf in den Cache', () {
+      expect(
+        NavidromeService.istAudioAntwort(200, 'application/octet-stream'),
+        isTrue,
+      );
+    });
+  });
+}