fix: Fehlerbehandlung beim Laden und Meldungen überarbeiten

Reklamationen der Fahrer: Meldungen verdeckten Buttons, und nach dem
Abschluss stand „Lieferung nicht in der Tour gefunden" ohne Ausweg da.

Meldungen:
- Erfolgs-SnackBars entfernt, bei Erfolg bleibt der Spinner
- einheitliche, schwebende Meldungen statt Stau über den Buttons
- Server-Rohtexte durch verständliche Texte ersetzt (api_failure_text)

Laden:
- fehlt eine geöffnete Lieferung, wird die Tour einmal neu geholt; die
  Meldung kommt nur nach erfolgreichem Abruf ohne die Lieferung
- Endlos-Spinner auf Lieferdetail, Filial-Abholung und Beladen ersetzt
  durch Kopfzeile, Fehlergrund und „Erneut versuchen"
- Tour wird nach einem Tageswechsel nachgeladen, offene Seiten bleiben
  dabei unberührt
- Abschluss und Zuweisung überschreiben kein zwischenzeitliches Neuladen,
  alte Antworten drehen einen Abschluss nicht mehr zurück
- leere Server-Antworten gelten als Fehler statt als „keine Daten"

Anmeldung:
- Token-Erneuerung wartet höchstens 12 s, der native Aufruf läuft weiter
- App-Start ohne Netz zeigt einen Hinweis mit „Erneut versuchen"
- Fehlerseite der Fahrzeugauswahl bietet „Abmelden"

Außerdem Podfile.lock an die Plugins angeglichen. Tests für die neuen
Fehlerpfade ergänzt.

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

lib/feature/delivery/overview/presentation/delivery_fail_page.dart

@@ -2,6 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:hl_lieferservice/feature/delivery/bloc/tour_bloc.dart';
 import 'package:hl_lieferservice/feature/delivery/bloc/tour_event.dart';
+import 'package:hl_lieferservice/feature/delivery/bloc/tour_state.dart';
 
 /// Fallback-Page, die der Übersichts- und Beladen-Pfad anzeigt, wenn der
 /// Initial-Tour-Load gescheitert ist. Tap auf "Erneut versuchen" feuert
@@ -16,6 +17,12 @@ class DeliveryLoadingFailedPage extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
+    final state = context.watch<TourBloc>().state;
+    final reason = switch (state) {
+      TourLoadFailed(:final message) => message,
+      TourLoaded(:final refreshError) => refreshError,
+      _ => null,
+    };
     return Center(
       child: Padding(
         padding: const EdgeInsets.all(50),
@@ -33,6 +40,11 @@ class DeliveryLoadingFailedPage extends StatelessWidget {
                 'Leider ist es beim Laden der Fahrten zu einem Fehler gekommen.',
               ),
             ),
+            if (reason != null)
+              Padding(
+                padding: const EdgeInsets.only(top: 12),
+                child: Text(reason, textAlign: TextAlign.center),
+              ),
             Padding(
               padding: const EdgeInsets.only(top: 30),
               child: FilledButton(

lib/feature/delivery/overview/presentation/delivery_sort_page.dart

@@ -47,9 +47,6 @@ class _DeliverySortPageState extends State<DeliverySortPage> {
   final SortableDeliveryListController _listController =
       SortableDeliveryListController();
 
-  /// Verhindert mehrfache SnackBars für denselben Fehler-State.
-  String? _lastShownErrorSignature;
-
   /// True, sobald `_confirm` gefeuert wurde — wir nutzen das, um den
   /// Übergang persisting → fertig zuverlässig zu erkennen.
   bool _isAwaitingConfirm = false;
@@ -222,19 +219,14 @@ class _DeliverySortPageState extends State<DeliverySortPage> {
       listener: (context, state) {
         if (state is! TourLoaded) return;
 
-        final err = state.reorderError;
-        if (err != null && err != _lastShownErrorSignature) {
-          _lastShownErrorSignature = err;
-          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(content: Text(err)),
-          );
+        // Die Meldung zeigt der OperationViewEnforcer (FailOperation im
+        // TourBloc); hier geht es nur darum, nicht weiterzuschalten.
+        if (state.reorderError != null) {
           _isAwaitingConfirm = false;
           return;
         }
 
-        if (_isAwaitingConfirm &&
-            !state.isPersistingReorder &&
-            err == null) {
+        if (_isAwaitingConfirm && !state.isPersistingReorder) {
           _isAwaitingConfirm = false;
           _advanceToLoading();
         }

lib/feature/delivery/overview/presentation/tour_day_watcher.dart

@@ -0,0 +1,58 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+
+import 'package:hl_lieferservice/feature/delivery/bloc/tour_bloc.dart';
+import 'package:hl_lieferservice/feature/delivery/bloc/tour_event.dart';
+
+/// Holt bei einem Tageswechsel die aktuelle Tour, sobald der Fahrer zur
+/// Tour-Ansicht zurückkehrt: beim Öffnen der App und beim Schließen einer
+/// darüberliegenden Seite.
+///
+/// Solange eine Seite darüber liegt (Lieferung, Unterschrift, Zahlung), wird
+/// nicht geladen: Die neue Tour enthielte die offene Lieferung nicht mehr, und
+/// der Fahrer verlöre seine Eingaben, z. B. bei einer Tour über Mitternacht.
+class TourDayWatcher extends StatefulWidget {
+  const TourDayWatcher({super.key, required this.child});
+
+  final Widget child;
+
+  @override
+  State<TourDayWatcher> createState() => _TourDayWatcherState();
+}
+
+class _TourDayWatcherState extends State<TourDayWatcher>
+    with WidgetsBindingObserver {
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addObserver(this);
+  }
+
+  @override
+  void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
+    super.dispose();
+  }
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    if (state == AppLifecycleState.resumed) _checkDay();
+  }
+
+  /// Läuft auch, wenn eine darüberliegende Seite geschlossen wird: `ModalRoute`
+  /// meldet dann, dass diese Route wieder die oberste ist.
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    _checkDay();
+  }
+
+  void _checkDay() {
+    if (ModalRoute.of(context)?.isCurrent ?? true) {
+      context.read<TourBloc>().add(const RefreshTourIfDayChanged());
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) => widget.child;
+}

lib/feature/delivery/overview/presentation/tour_not_loaded_scaffold.dart

@@ -0,0 +1,117 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+
+import 'package:hl_lieferservice/feature/delivery/bloc/tour_bloc.dart';
+import 'package:hl_lieferservice/feature/delivery/bloc/tour_event.dart';
+import 'package:hl_lieferservice/feature/delivery/bloc/tour_state.dart';
+import 'package:hl_lieferservice/feature/delivery/overview/presentation/delivery_fail_page.dart';
+import 'package:hl_lieferservice/widget/app_message.dart';
+
+/// Rahmen für Unterseiten einer Lieferung, solange keine Tour-Daten vorliegen.
+///
+/// Immer mit Kopfzeile: Scheitert das Laden, bleibt der Fahrer sonst ohne
+/// Zurück-Button vor einem Spinner stehen.
+class TourNotLoadedScaffold extends StatelessWidget {
+  const TourNotLoadedScaffold({
+    super.key,
+    required this.title,
+    required this.state,
+  });
+
+  final String title;
+  final TourState state;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text(title)),
+      body: SafeArea(
+        child: switch (state) {
+          TourLoadFailed() ||
+          TourLoaded(
+            refreshError: String _,
+          ) => const DeliveryLoadingFailedPage(),
+          TourEmpty() => const _NoTour(),
+          _ => const Center(child: CircularProgressIndicator()),
+        },
+      ),
+    );
+  }
+}
+
+class _NoTour extends StatelessWidget {
+  const _NoTour();
+
+  @override
+  Widget build(BuildContext context) {
+    return Center(
+      child: Padding(
+        padding: const EdgeInsets.all(32),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            const Text(
+              'Für diesen Tag ist keine Tour zugewiesen.',
+              textAlign: TextAlign.center,
+            ),
+            const SizedBox(height: 16),
+            FilledButton.tonalIcon(
+              onPressed: () => context.read<TourBloc>().add(const LoadTour()),
+              icon: const Icon(Icons.refresh),
+              label: const Text('Neu laden'),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+/// Für Seiten einer einzelnen Lieferung: Fehlt sie in den geladenen Daten, wird
+/// die Tour erst einmal neu geholt. Die Meldung kommt nur, wenn sie auch nach
+/// einem **erfolgreichen** Neuladen fehlt. Scheitert das Neuladen, ist nichts
+/// bewiesen; die Seite zeigt dann den Fehler mit „Erneut versuchen".
+mixin DeliveryPresenceGuard<T extends StatefulWidget> on State<T> {
+  String get guardedDeliveryId;
+
+  bool _refetched = false;
+  bool _left = false;
+
+  /// Aus dem Listener auf den [TourBloc] aufrufen. Liefert `true`, wenn die
+  /// Lieferung in den geladenen Daten steht.
+  bool deliveryStillPresent(BuildContext context, TourState state) {
+    if (_left) return false;
+    if (state is TourLoaded) {
+      if (state.details.deliveries.any((d) => d.id == guardedDeliveryId)) {
+        _refetched = false;
+        return true;
+      }
+      if (state.isRefreshing) return false;
+      if (_refetched && state.refreshError != null) return false;
+    } else if (state is! TourEmpty) {
+      return false;
+    }
+
+    // Hier steht fest: Eine Antwort des Servers enthält die Lieferung nicht.
+    if (!_refetched) {
+      _refetched = true;
+      context.read<TourBloc>().add(const RefreshTour());
+      return false;
+    }
+    _left = true;
+    _leaveUnavailableDelivery(context);
+    return false;
+  }
+}
+
+/// Führt zurück zur Übersicht, wenn die geöffnete Lieferung nicht in der
+/// geladenen Tour steht. Das sagt nichts darüber, ob es sie gibt: Sie kann zu
+/// einem anderen Tag gehören. Schließt auch Seiten, die darüber liegen
+/// (Unterschrift, Zahlung): Sie beziehen sich auf dieselbe Lieferung.
+void _leaveUnavailableDelivery(BuildContext context) {
+  context.showAppMessage(
+    'Diese Lieferung ist in der geladenen Tour nicht enthalten. '
+    'Bitte das Tour-Datum prüfen.',
+  );
+  Navigator.of(context).popUntil((route) => route.isFirst);
+}