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/downloads/online_screen_test.dart

@@ -1,6 +1,7 @@
 import 'dart:convert';
 
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart';
@@ -35,8 +36,38 @@ Widget _wrap(BakaAuth auth) {
   );
 }
 
+Future<BakaAuth> _angemeldet() async {
+  final auth = BakaAuth(
+    client:
+        MockClient((_) async => http.Response(jsonEncode({'token': 'jwt'}), 200)),
+    speicher: _MemorySpeicher(),
+  );
+  await auth.anmelden('Baka', 'geheim');
+  return auth;
+}
+
 void main() {
-  setUp(() => SharedPreferences.setMockInitialValues({}));
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  const medienKanal = MethodChannel('de.baka.melo/media_store');
+  final messenger =
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger;
+
+  /// Ein Handy ohne SD-Karte — mehr Speicherorte setzt der jeweilige Test.
+  void nurInternerSpeicher() {
+    messenger.setMockMethodCallHandler(medienKanal, (call) async {
+      if (call.method != 'listVolumes') return null;
+      return [
+        {'name': 'external_primary', 'beschreibung': 'Interner Speicher'},
+      ];
+    });
+  }
+
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+    nurInternerSpeicher();
+  });
+  tearDown(() => messenger.setMockMethodCallHandler(medienKanal, null));
 
   testWidgets('Online-Tab hat die Unterreiter YouTube und Server',
       (tester) async {
@@ -80,4 +111,62 @@ void main() {
     expect(find.byType(TextField), findsOneWidget);
     expect(find.text('Herunterladen'), findsOneWidget);
   });
+
+  testWidgets('Der Cookie-Schalter steht anfangs an', (tester) async {
+    await tester.pumpWidget(_wrap(await _angemeldet()));
+    await tester.pumpAndSettle();
+
+    expect(find.text('YouTube-Cookies des Servers verwenden'), findsOneWidget);
+    expect(tester.widget<SwitchListTile>(find.byType(SwitchListTile)).value,
+        isTrue);
+  });
+
+  testWidgets('Abschalten des Cookie-Schalters wird gemerkt', (tester) async {
+    await tester.pumpWidget(_wrap(await _angemeldet()));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byType(SwitchListTile));
+    await tester.pumpAndSettle();
+
+    expect(tester.widget<SwitchListTile>(find.byType(SwitchListTile)).value,
+        isFalse);
+    final prefs = await SharedPreferences.getInstance();
+    expect(prefs.getBool('yt_cookies'), isFalse);
+  });
+
+  testWidgets('Gemerktes Abschalten gilt auch nach dem Neustart',
+      (tester) async {
+    SharedPreferences.setMockInitialValues({'yt_cookies': false});
+
+    await tester.pumpWidget(_wrap(await _angemeldet()));
+    await tester.pumpAndSettle();
+
+    expect(tester.widget<SwitchListTile>(find.byType(SwitchListTile)).value,
+        isFalse);
+  });
+
+  testWidgets('Mehrere Speicherorte bringen die Auswahl zum Vorschein',
+      (tester) async {
+    messenger.setMockMethodCallHandler(medienKanal, (call) async {
+      if (call.method != 'listVolumes') return null;
+      return [
+        {'name': 'external_primary', 'beschreibung': 'Interner Speicher'},
+        {'name': '1234-abcd', 'beschreibung': 'SD-Karte (1234-abcd)'},
+      ];
+    });
+
+    await tester.pumpWidget(_wrap(await _angemeldet()));
+    await tester.pumpAndSettle();
+
+    expect(find.byType(DropdownButtonFormField<String>), findsOneWidget);
+    expect(find.text('Speicherort'), findsOneWidget);
+  });
+
+  testWidgets('Bei nur einem Speicherort gibt es keine Auswahl',
+      (tester) async {
+    await tester.pumpWidget(_wrap(await _angemeldet()));
+    await tester.pumpAndSettle();
+
+    expect(find.byType(DropdownButtonFormField<String>), findsNothing);
+  });
 }