Phase 4.A.1: Live Activity + Dynamic Island für laufende Gassi-Tour

Neues Widget-Extension-Target BanYaroGoWidgetExtension:
- Bundle-ID app.banyaro.ios.BanYaroGoWidget
- NSExtensionPointIdentifier = com.apple.widgetkit-extension
- Synced root group + explizite Info.plist + Embed-Phase in App-Target
- Cross-Membership der Shared/WalkActivityAttributes.swift in beiden Targets

Shared/WalkActivityAttributes.swift:
- ActivityAttributes mit startedAt (fix)
- ContentState mit distanceMeters, elapsedSeconds, pointCount, isPaused, isAutoPaused

BanYaroGoWidget/WalkLiveActivity.swift:
- Lock-Screen-View: Pfote-Icon + Status-Pille (Live/Pause/Auto-Pause) +
  Stats-Spalten (Distanz/Dauer/Punkte)
- Dynamic Island compact: Pfote leading, Distanz trailing
- Dynamic Island minimal: nur Pfote
- Dynamic Island expanded: Distanz/Dauer/Status mit Pfote zentriert

WalkActivityController:
- @MainActor Facade um ActivityKit
- start() prüft areActivitiesEnabled, killt orphaned current, request mit Initial-State
- update() async via Task
- end() mit dismissalPolicy.immediate

TrackingView:
- .onChange(of: tracker.isTracking) → Start/End
- persistTicker (5s) → update
- .onChange(of: tracker.isPaused/isAutoPaused) → sofort update für saubere UX

BanYaroGo-Info.plist: NSSupportsLiveActivities = true

BanYaroGo/Tracking/WalkActivityController.swift

@@ -0,0 +1,41 @@
+import Foundation
+import ActivityKit
+
+/// Tiny facade around ActivityKit so TrackingView doesn't have to know the
+/// details. There is at most one walk activity alive at any time.
+@MainActor
+enum WalkActivityController {
+    private static var current: Activity<WalkActivityAttributes>?
+
+    static func start(startedAt: Date, initialState: WalkActivityAttributes.WalkActivityState) {
+        guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+        // Kill anything left over from a previous (orphaned) session.
+        if current != nil { end() }
+        let attributes = WalkActivityAttributes(startedAt: startedAt)
+        let content = ActivityContent(state: initialState, staleDate: nil)
+        do {
+            current = try Activity.request(
+                attributes: attributes,
+                content: content,
+                pushType: nil
+            )
+        } catch {
+            print("Live Activity request failed: \(error)")
+        }
+    }
+
+    static func update(_ state: WalkActivityAttributes.WalkActivityState) {
+        let activity = current
+        Task { @MainActor in
+            await activity?.update(ActivityContent(state: state, staleDate: nil))
+        }
+    }
+
+    static func end() {
+        let activity = current
+        current = nil
+        Task { @MainActor in
+            await activity?.end(nil, dismissalPolicy: .immediate)
+        }
+    }
+}

BanYaroGo/Views/TrackingView.swift

@@ -34,7 +34,17 @@ struct TrackingView: View {
         .onReceive(persistTicker) { _ in
             tracker.checkAutoPause()
             persistActive()
+            updateLiveActivity()
         }
+        .onChange(of: tracker.isTracking) { _, isTracking in
+            if isTracking {
+                startLiveActivity()
+            } else {
+                WalkActivityController.end()
+            }
+        }
+        .onChange(of: tracker.isPaused) { _, _ in updateLiveActivity() }
+        .onChange(of: tracker.isAutoPaused) { _, _ in updateLiveActivity() }
         .onAppear { offerResumeIfNeeded() }
         .sheet(isPresented: $showFinishSheet) {
             FinishWalkSheet(
@@ -320,6 +330,29 @@ struct TrackingView: View {
 
     // MARK: - Helpers
 
+    private func startLiveActivity() {
+        guard let startedAt = tracker.startedAt else { return }
+        WalkActivityController.start(
+            startedAt: startedAt,
+            initialState: liveActivityState()
+        )
+    }
+
+    private func updateLiveActivity() {
+        guard tracker.isTracking else { return }
+        WalkActivityController.update(liveActivityState())
+    }
+
+    private func liveActivityState() -> WalkActivityAttributes.WalkActivityState {
+        WalkActivityAttributes.WalkActivityState(
+            distanceMeters: tracker.totalDistanceMeters,
+            elapsedSeconds: tracker.effectiveElapsedSeconds,
+            pointCount: tracker.points.count,
+            isPaused: tracker.isPaused,
+            isAutoPaused: tracker.isAutoPaused
+        )
+    }
+
     private func formatDuration(_ seconds: Int) -> String {
         let h = seconds / 3600
         let m = (seconds % 3600) / 60