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/PlaybackScrubber.swift

@@ -0,0 +1,119 @@
+import SwiftUI
+import HaloDesign
+
+/// Der Regler unter dem Film — mit dem, was schon geladen ist.
+///
+/// **Warum nicht `Slider`.** Ein `Slider` hat genau eine Spur, und die gehört
+/// dem Fortschritt. Was bereits geladen ist, lässt sich dort nicht
+/// unterbringen — und das ist die Auskunft, um die es hier geht: wie weit
+/// kann ich springen, ohne zu warten. Dahinter etwas zu zeichnen und auf
+/// gleiche Ausrichtung zu hoffen ginge so lange gut, bis Apple die
+/// Innenabstände ändert.
+///
+/// Drei Schichten übereinander, alle aus derselben Rechnung:
+///
+///     Grund      ── die ganze Länge, gedämpft
+///     Geladen    ── bis wohin Daten da sind, heller
+///     Gespielt   ── bis zur Abspielstelle, in der Akzentfarbe
+///
+/// **Der Griff ist grösser als der Strich.** Vier Punkte hoch trifft niemand
+/// mit dem Finger; der unsichtbare Bereich darüber ist deshalb so hoch wie
+/// eine Zeile.
+struct PlaybackScrubber: View {
+    /// Wo abgespielt wird.
+    let position: Duration
+    /// Wie lang das Ganze ist.
+    let duration: Duration
+    /// Bis wohin geladen ist — `nil`, wenn es niemand weiss.
+    let buffered: Duration?
+    /// Ob gerade gezogen wird; dann bleibt der Griff gross.
+    @Binding var scrubbing: Double?
+
+    /// Beim Loslassen, mit dem Ziel.
+    let onCommit: (Duration) -> Void
+    /// Bei jeder Berührung — damit die Bedienung stehen bleibt.
+    let onActivity: () -> Void
+
+    @Environment(\.haloAccent) private var accent
+
+    private static let trackHeight: CGFloat = 5
+    private static let thumbSize: CGFloat = 13
+    /// So hoch, dass ein Finger ihn trifft.
+    private static let hitHeight: CGFloat = 34
+
+    var body: some View {
+        GeometryReader { geometry in
+            let breite = geometry.size.width
+            let gespielt = anteil(of: angezeigt) * breite
+            let geladen = buffered.map { anteil(of: $0) * breite } ?? 0
+
+            ZStack(alignment: .leading) {
+                Capsule()
+                    .fill(.white.opacity(0.22))
+                    .frame(height: Self.trackHeight)
+
+                // Nur wenn er weiter reicht als das Gespielte. Sonst sähe man
+                // einen Balken, der hinter der Abspielstelle zurückbleibt —
+                // und das behauptete etwas Falsches.
+                if geladen > gespielt {
+                    Capsule()
+                        .fill(.white.opacity(0.45))
+                        .frame(width: geladen, height: Self.trackHeight)
+                }
+
+                Capsule()
+                    .fill(accent)
+                    .frame(width: gespielt, height: Self.trackHeight)
+
+                Circle()
+                    .fill(accent)
+                    .frame(width: scrubbing == nil ? Self.thumbSize : Self.thumbSize * 1.5)
+                    .offset(x: gespielt - Self.thumbSize / 2)
+                    .animation(.easeOut(duration: 0.15), value: scrubbing == nil)
+            }
+            .frame(height: Self.hitHeight)
+            .contentShape(.rect)
+            .gesture(
+                DragGesture(minimumDistance: 0)
+                    .onChanged { wert in
+                        scrubbing = sekunden(at: wert.location.x, width: breite)
+                        onActivity()
+                    }
+                    .onEnded { wert in
+                        let ziel = sekunden(at: wert.location.x, width: breite)
+                        scrubbing = nil
+                        onCommit(.seconds(ziel))
+                        onActivity()
+                    }
+            )
+        }
+        .frame(height: Self.hitHeight)
+        .accessibilityElement()
+        .accessibilityLabel(Text("player.position"))
+        .accessibilityValue(Text(angezeigt.timecode))
+        .accessibilityAdjustableAction { richtung in
+            let schritt = Duration.seconds(15)
+            switch richtung {
+            case .increment: onCommit(min(angezeigt + schritt, duration))
+            case .decrement: onCommit(max(.zero, angezeigt - schritt))
+            @unknown default: break
+            }
+        }
+    }
+
+    /// Was der Regler zeigt: beim Ziehen der Finger, sonst die Wiedergabe.
+    private var angezeigt: Duration {
+        scrubbing.map(Duration.seconds) ?? position
+    }
+
+    private func anteil(of zeit: Duration) -> CGFloat {
+        let gesamt = duration.seconds
+        guard gesamt > 0 else { return 0 }
+        return min(max(CGFloat(zeit.seconds / gesamt), 0), 1)
+    }
+
+    private func sekunden(at x: CGFloat, width: CGFloat) -> Double {
+        guard width > 0 else { return 0 }
+        return min(max(Double(x / width), 0), 1) * duration.seconds
+    }
+}