road distance: pin-fingerprint guard so embedded/live/cached never cross-pollute

The road-distance cache was keyed purely by station ID with no coordinate, so
a value routed to one pin could be served for a same-ID station whose stored
coordinate came from a different source (live fetch vs bundled offline dump
vs a corrected pin), reproducing Maps mismatches.
- RoadDistanceCache now stores each routed pin (CachedRoadDistance{meters,
  lat, lng}) and roadDistanceMeters() only serves a value when the displayed
  station's coordinate matches the pinned one (within ~11 m).
- Kept the existing origin-distance staleness guard.
- Verified embedded sample data (ids y1/se1/...) never collides with real
  relay IDs, and the widget STRICT radius filter drops far-offline samples, so
  no actual leak existed in practice — this closes the theoretical stale-pin
  channel and future-proofs against coordinate fixes.

FuelBoard/RoadDistanceService.swift

@@ -51,11 +51,16 @@ enum RoadDistanceService {
             .filter { $0.distanceKM(to: lat, lng2: lng) <= maxRadiusKM }
 
         let origin = CLLocationCoordinate2D(latitude: lat, longitude: lng)
-        var entries: [String: Double] = [:]
+        var entries: [String: CachedRoadDistance] = [:]
         for station in nearest {
             let dest = CLLocationCoordinate2D(latitude: station.lat, longitude: station.lng)
             if let meters = await roadMeters(from: origin, to: dest) {
-                entries[station.id] = meters
+                // Store the exact pin that was routed so the display layer can
+                // refuse to serve this value if the station later appears with
+                // a different coordinate (corrected pin / other data source).
+                entries[station.id] = CachedRoadDistance(meters: meters,
+                                                         lat: station.lat,
+                                                         lng: station.lng)
             }
         }
         guard !entries.isEmpty else { return }