mobile: wind arrows anchor to ground + consistent density

Two fixes to the wind overlay:
- Snap arrow positions to a fixed lat/lon lattice (multiples of step) so they
  stay ground-anchored and scroll with the map on pan, instead of being
  re-placed across the viewport each frame (which looked screen-locked).
- Drop the 0.25° data-resolution floor: ~12 arrows across the view at any
  zoom, with bilinear interpolation (WindField.sampleInterp) so sub-grid
  sampling stays smooth rather than sparse when zoomed in.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016m9NjsSfBSx1RgN3fpnx7e

Author: claude

mobile/lib/map_screen.dart

@@ -110,12 +110,17 @@ class _MapScreenState extends State<MapScreen> {
     }
     final markers = <Marker>[];
     final span = math.max(b.east - b.west, b.north - b.south);
-    final step = math.max(f.dx, span / 14);
+    // ~12 arrows across the view at any zoom (not tied to the 0.25° grid).
+    final step = (span / 12).clamp(0.02, 5.0).toDouble();
     if (step > 0) {
-      for (double lat = b.north; lat >= b.south; lat -= step) {
-        for (double lon = b.west; lon <= b.east; lon += step) {
+      // Snap the lattice to multiples of `step` so arrows stay anchored to the
+      // ground and scroll with the map when panning (instead of the viewport).
+      final lat0 = (b.south / step).floorToDouble() * step;
+      final lon0 = (b.west / step).floorToDouble() * step;
+      for (double lat = lat0; lat <= b.north; lat += step) {
+        for (double lon = lon0; lon <= b.east; lon += step) {
           final nlon = ((lon + 540) % 360) - 180;
-          final s = f.sample(nlon, lat);
+          final s = f.sampleInterp(nlon, lat);
           if (s == null) continue;
           final knots = math.sqrt(s.u * s.u + s.v * s.v) * 1.94384;
           final ang = math.atan2(s.u, s.v); // bearing wind blows toward

mobile/lib/weather.dart

@@ -38,6 +38,46 @@ class WindField {
     return (u: u[idx], v: v[idx]);
   }
 
+  /// Bilinearly-interpolated (u, v) for a lon/lat — smooth between grid cells
+  /// so arrows can be drawn finer than the 0.25° data. Falls back to nearest at
+  /// the grid edges. Null if fully out of range.
+  ({double u, double v})? sampleInterp(double lon, double lat) {
+    if (dx <= 0 || dy <= 0) return null;
+    final l = ((lon - lo1) % 360 + 360) % 360;
+    final fx = l / dx;
+    final fy = (la1 - lat) / dy;
+    final ix = fx.floor(), iy = fy.floor();
+    final tx = fx - ix, ty = fy - iy;
+    double? g(int gx, int gy, List<double> a) {
+      if (gy < 0 || gy >= ny) return null;
+      final wx = ((gx % nx) + nx) % nx;
+      final idx = gy * nx + wx;
+      if (idx < 0 || idx >= a.length) return null;
+      return a[idx];
+    }
+
+    final u00 = g(ix, iy, u), u10 = g(ix + 1, iy, u);
+    final u01 = g(ix, iy + 1, u), u11 = g(ix + 1, iy + 1, u);
+    final v00 = g(ix, iy, v), v10 = g(ix + 1, iy, v);
+    final v01 = g(ix, iy + 1, v), v11 = g(ix + 1, iy + 1, v);
+    if (u00 == null ||
+        u10 == null ||
+        u01 == null ||
+        u11 == null ||
+        v00 == null ||
+        v10 == null ||
+        v01 == null ||
+        v11 == null) {
+      return sample(lon, lat); // fall back to nearest at edges
+    }
+    double bil(double a, double b, double c, double d) =>
+        a * (1 - tx) * (1 - ty) +
+        b * tx * (1 - ty) +
+        c * (1 - tx) * ty +
+        d * tx * ty;
+    return (u: bil(u00, u10, u01, u11), v: bil(v00, v10, v01, v11));
+  }
+
   /// Wind speed in knots for a lon/lat, or null.
   double? speedKnots(double lon, double lat) {
     final s = sample(lon, lat);