Flixy heißt ab hier Halo

Reine Umbenennung, kein Verhalten geändert — bewusst als eigener Commit,
damit „umbenannt" und „umgebaut" im Nachhinein auseinanderzuhalten sind.

712 mal `Flixy`, 778 mal `flixy`, 7 mal `FLIXY` in 169 Dateien, dazu 25
Pfade. Ziele: `Halo`, `HaloTV`, `HaloTopShelf`, `HaloUITests`, `HaloKit` mit
`HaloDesign`, `HaloDownloads`, `HaloPlayback` und `HaloProbe`. `MediaKit`,
`JellyfinKit` und `DownloadWidget` tragen den Namen nicht und bleiben.

`docs/superpowers/specs/` ist ausgenommen. Datierte Entwurfsdokumente sind
ein Protokoll getroffener Entscheidungen; sie nachträglich umzuschreiben
hiesse, die Vergangenheit zu glätten.

**Die Bundle-ID wandert mit** — ausdrücklich so gewollt, mit bekanntem Preis:
`com.scarriffleservices.halo` ist für iOS eine *andere* App. Die installierte
Fassung bleibt daneben stehen, mit Downloads und Anmeldung in ihrem Container;
Halo startet leer. Einmal neu anmelden, heruntergeladene Folgen einmal neu
laden. Dasselbe gilt für die App-Gruppe, die sich TV-App und Top Shelf teilen.

**Eine Folge davon, die beim Entscheiden noch nicht auf dem Tisch lag:** der
Aufräumschritt aus dem vorigen Commit kommt an die alten Plex-Token nicht mehr
heran. Der Schlüsselbund grenzt nach Team und Bundle-Kennung ab — was unter
`…flixy` liegt, ist für `…halo` unerreichbar. Erledigt wird es trotzdem, nur
anders: **die alte App löschen.** iOS räumt deren Schlüsselbund-Einträge beim
Deinstallieren mit ab. Der Code bleibt stehen, weil er für jeden Stand vor
dieser Umbenennung richtig ist und im Jahr einen Startvergleich kostet.

Die Projektdatei ist aus `project.yml` neu erzeugt, der alte Ordner gelöscht
statt umbenannt — sie steht ohnehin nicht im Repo.

Das Verzeichnis des Repos selbst heißt weiter `Flixy`; das umzubenennen ist
ein Handgriff ausserhalb des Projekts.

368 Tests grün. iOS und tvOS bauen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Halo/Views/Player/TrackPickerSheet.swift

@@ -0,0 +1,152 @@
+import SwiftUI
+import HaloDesign
+import HaloPlayback
+import MediaKit
+
+/// Auswahl einer Spur — Ton **oder** Untertitel, nicht beides.
+///
+/// Getrennt, weil es zwei verschiedene Fragen sind: die Tonspur wechselt man
+/// einmal am Anfang, die Untertitel mitten im Film. Beide in einem Sheet
+/// bedeutete jedes Mal Scrollen an der anderen Liste vorbei.
+struct TrackPickerSheet: View {
+    enum Kind: Identifiable {
+        case audio
+        case subtitles
+
+        var id: Self { self }
+
+        var title: LocalizedStringKey {
+            switch self {
+            case .audio: "player.audioTracks"
+            case .subtitles: "player.subtitleTracks"
+            }
+        }
+    }
+
+    let model: PlayerModel
+    let kind: Kind
+
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.haloAccent) private var accent
+
+    var body: some View {
+        NavigationStack {
+            List {
+                switch kind {
+                case .audio where model.isOffline:
+                    // **Offline zählt, was in der Datei liegt.** Die Liste des
+                    // Servers gibt es hier nicht: `chooseAudioStream` läuft nur
+                    // auf dem Online-Weg. Solange sie trotzdem gefragt wurde,
+                    // blieb die Auswahl für heruntergeladene Titel leer — der
+                    // Knopf war da, das Sheet zeigte nichts.
+                    ForEach(model.audioTracks) { track in
+                        row(title: track.displayName, isSelected: model.selectedAudioTrack == track) {
+                            model.selectAudioTrack(track)
+                            dismiss()
+                        }
+                    }
+
+                case .audio:
+                    // **Die Spuren der Datei, nicht die des Players.** Rechnet
+                    // der Server um, kennt der Player genau eine — die, für
+                    // die er sich entschieden hat. Zur Auswahl steht, was in
+                    // der Datei liegt.
+                    ForEach(model.audioStreams) { stream in
+                        row(
+                            title: stream.name,
+                            isSelected: model.selectedAudioStream == stream
+                        ) {
+                            Task { await model.selectAudioStream(stream) }
+                            dismiss()
+                        }
+                    }
+
+                    if let gemerkt = model.rememberedTrackName {
+                        Section {
+                            Button(role: .destructive) {
+                                model.forgetRememberedTrack()
+                            } label: {
+                                Label("player.forgetRememberedTrack", systemImage: "arrow.uturn.backward")
+                            }
+                            .listRowBackground(Color.haloSurface)
+                        } header: {
+                            Text("player.rememberedTrack")
+                        } footer: {
+                            // Eine automatische Handlung, die man nicht sehen
+                            // kann, ist von einem Fehler nicht zu
+                            // unterscheiden.
+                            Text("player.rememberedTrackExplanation \(gemerkt)")
+                        }
+                    }
+
+                case .subtitles where model.isOffline:
+                    row(
+                        title: String(localized: "player.subtitlesOff"),
+                        isSelected: model.selectedSubtitleTrack == nil
+                    ) {
+                        model.selectSubtitleTrack(nil)
+                        dismiss()
+                    }
+
+                    ForEach(model.subtitleTracks) { track in
+                        row(title: track.displayName, isSelected: model.selectedSubtitleTrack == track) {
+                            model.selectSubtitleTrack(track)
+                            dismiss()
+                        }
+                    }
+
+                case .subtitles:
+                    // „Aus" gehört in dieselbe Liste wie die Spuren, nicht als
+                    // eigener Schalter daneben: es ist eine Auswahl unter
+                    // mehreren, keine getrennte Eigenschaft.
+                    row(
+                        title: String(localized: "player.subtitlesOff"),
+                        isSelected: model.selectedSubtitleStream == nil
+                    ) {
+                        Task { await model.selectSubtitleStream(nil) }
+                        dismiss()
+                    }
+
+                    // Wie beim Ton die Spuren der Datei: ein umgerechneter
+                    // Stream bringt genau einen mit, und der heisst „CC".
+                    ForEach(model.subtitleStreams) { stream in
+                        row(
+                            title: stream.name,
+                            isSelected: model.selectedSubtitleStream == stream
+                        ) {
+                            Task { await model.selectSubtitleStream(stream) }
+                            dismiss()
+                        }
+                    }
+                }
+            }
+            .scrollContentBackground(.hidden)
+            .background(Color.haloCanvas)
+            .navigationTitle(Text(kind.title))
+            .haloInlineTitle()
+            .toolbar {
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("action.close") { dismiss() }
+                }
+            }
+        }
+        .haloMediumSheet()
+    }
+
+    private func row(title: String, isSelected: Bool, action: @escaping () -> Void) -> some View {
+        Button(action: action) {
+            HStack {
+                Text(title)
+                    .foregroundStyle(Color.haloTextPrimary)
+                Spacer()
+                if isSelected {
+                    Image(systemName: "checkmark").foregroundStyle(accent)
+                }
+            }
+            .contentShape(.rect)
+        }
+        .buttonStyle(.plain)
+        .listRowBackground(Color.haloSurface)
+        .accessibilityAddTraits(isSelected ? [.isButton, .isSelected] : .isButton)
+    }
+}