Animate the radar timeline with a double-buffered overlay

Completes milestone 3: frames render over the map, play as a loop, and can be
scrubbed, with the legend drawn from the manifest rather than a constant that
could drift from what the worker actually rendered.

The overlay alternates two MapLibre image sources. Updating one source in place
flickers, because the layer briefly shows a half-written texture; adding every
frame as its own layer avoids that but pins them all in GPU memory, and twenty
512x512 RGBA frames is about 80 MB. Two buffers cost the same whether the
timeline holds six frames or sixty. Platform-channel work is serialised because
`show` is called faster than the round trip completes during playback, and
overlapping updates would swap visibility out of order and strobe.

Prefetching loads a window around the playhead, nearest first and forward
before backward, since playback moves forward and that frame is needed
soonest. `FrameCache` is byte-budgeted rather than entry-counted because frame
size tracks how much precipitation is on screen, and it evicts by distance from
the playhead: plain LRU would keep frames the prefetcher touched a moment ago
even after the playhead moved to the far end of the timeline.

Also adds DpcRadarSource, which reads published frames from our CDN and never
from the DPC API. Without it, the `dpc` adapter would have had to fall back to
mock, putting demo frames on screen under the label of live data — exactly the
confusion the adapter split exists to prevent. It now fails naming the missing
setting instead.

Running it on the emulator caught three things the tests had not:

- The notifier wrote to `state` from inside `build()`, which Riverpod rejects
  as an uninitialised provider. That broke startup, not just tests.
- Eight-month-old demo frames rendered as "Aggiornato 342535 minuti fa". The
  age formatter now steps up to hours and days.
- Demo mode sat permanently behind a stale-data warning and so never showed the
  working state it exists to demonstrate. MockRadarSource now shifts the
  bundled timestamps onto the present, leaving images, order and spacing
  untouched, so the timeline behaves exactly as it would on live data.

Corrects docs/stack-decisions.md, which described a disk cache that was not
built: mock frames already live in the asset bundle, so a disk layer belongs
with the network adapter where it would save a real request.

Verified: analyze clean, 129 tests passing, and on the emulator the loop
advances, wraps, and reports "Aggiornato ora".

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

Nuvolari/app/lib/features/timeline/data_age_banner.dart

@@ -0,0 +1,100 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../l10n/app_localizations.dart';
+import 'radar_timeline.dart';
+
+/// Renders [age] at a scale a reader can take in at a glance.
+///
+/// Minutes alone stop being informative quickly: data three days old reads as
+/// "Aggiornato 4320 minuti fa", which is a number nobody converts in their
+/// head. The unit steps up so the magnitude is obvious even when the exact
+/// figure is not.
+String formatDataAge(AppLocalizations l10n, Duration age) {
+  final clamped = age.isNegative ? Duration.zero : age;
+  if (clamped.inHours < 1) return l10n.dataAgeMinutes(clamped.inMinutes);
+  if (clamped.inDays < 1) return l10n.dataAgeHours(clamped.inHours);
+  return l10n.dataAgeDays(clamped.inDays);
+}
+
+/// States the age of the radar data, and says so loudly when it is stale.
+///
+/// Radar shown without its age is radar the reader will assume is current. That
+/// is the failure mode that matters for a weather app: someone deciding whether
+/// to leave the house based on a picture of the sky from an hour ago. So the
+/// age is always on screen, not only when something has gone wrong.
+class DataAgeBanner extends ConsumerWidget {
+  const DataAgeBanner({super.key, this.now});
+
+  /// Injectable clock for tests.
+  final DateTime? now;
+
+  /// Beyond this the data stops being "the current picture".
+  ///
+  /// Frames arrive every five minutes, so a gap this size means several
+  /// publishes were missed, not that one is slightly late.
+  static const Duration staleAfter = Duration(minutes: 20);
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final l10n = AppLocalizations.of(context);
+    final theme = Theme.of(context);
+    final state = ref.watch(radarTimelineProvider);
+    final manifest = state.manifest;
+
+    if (manifest == null || manifest.isEmpty) {
+      // Nothing to date. Whether that is a failure or a first load is the
+      // timeline bar's business, not this widget's.
+      return const SizedBox.shrink();
+    }
+
+    final age = manifest.ageAt(now ?? DateTime.now());
+    final ageText = formatDataAge(l10n, age);
+    final isStale = age >= staleAfter || state.error != null;
+
+    if (!isStale) {
+      // Full width and left aligned, matching the stale variant below, so the
+      // text does not jump across the screen when the state flips.
+      return SizedBox(
+        width: double.infinity,
+        child: Padding(
+          padding: const EdgeInsets.fromLTRB(16, 0, 16, 4),
+          child: Text(
+            ageText,
+            style: theme.textTheme.bodySmall?.copyWith(
+              color: theme.colorScheme.outline,
+            ),
+          ),
+        ),
+      );
+    }
+
+    return Container(
+      width: double.infinity,
+      color: theme.colorScheme.errorContainer,
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+      child: Row(
+        children: [
+          Icon(
+            Icons.warning_amber_rounded,
+            size: 18,
+            color: theme.colorScheme.onErrorContainer,
+          ),
+          const SizedBox(width: 8),
+          Expanded(
+            child: Text(
+              // The age goes inside the warning rather than replacing it: "not
+              // updated" alone leaves the reader guessing how far off it is.
+              state.error != null
+                  ? '${l10n.dataUnavailable} · $ageText'
+                  : l10n.radarStaleWithAge(ageText),
+              style: theme.textTheme.bodySmall?.copyWith(
+                color: theme.colorScheme.onErrorContainer,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}