Build driver app, Uber-style dispatch, POI suggestions; fix map tiles

Driver side (was a stub):
- In-app driver onboarding: a driver-role user creates their own linked
  drivers profile (driver/profile+api GET/POST/PATCH).
- Driver dashboard: online/offline toggle, today's earnings, incoming
  request cards (accept/decline), active ride panel (start/complete trip).
  Polls /driver/rides every 4s while online.
- Location heartbeat (use-driver-location): watchPositionAsync pings
  /driver/location every ~5s; restarts the watch on app foreground so a
  backgrounded driver doesn't go permanently stale and miss requests.

Dispatch (auto-match nearest, Uber-style):
- Ride state machine: requested -> accepted -> en_route -> completed/cancelled
  with a nullable driver_id until matched (lib/dispatch.matchNextDriver).
- matchNextDriver locks the ride (SELECT FOR UPDATE), expires 15s-stale
  offers, picks the nearest eligible driver of the matching service by
  haversine, offers one at a time. Called from ride/create, ride/[id] GET
  (lazy match on the rider's poll), and ride/[id]/respond (on decline).
- ride/create is now a request endpoint (driver_id NULL, status=requested,
  service); drops the pre-match driver_id payment reconciliation.
- ride/[id] GET returns status/service/nullable driver; PATCH handles rider
  cancel + driver en_route/completed. ride/list backs the history tabs.

Rider flow (best experience):
- confirm-ride is now a request screen: single trip fare + nearest-driver
  ETA + cash/card + Request Ride -> live status. Periodically polls online
  drivers of the selected service and disables Request when none are
  online (prevents the "stuck searching forever" state).
- book-ride is the live ride-status screen (searching -> accepted ->
  en_route -> completed/cancelled + Cancel), polling every 3s.
- lib/request-ride unifies the Areeba card flow + cash path.
- Map reads /driver/nearby (real positions, service-filtered); lib/map
  adds calculateTripFare + service-aware fares.

POI suggestions:
- lib/places (Google Nearby Search) + nearby-suggestions chips for
  mall/hospital/pharmacy/restaurant on the home screen.

Service categories now drive both matching and a per-service fare
multiplier (car 1.0 / moto 0.7 / courier 0.85 / chauffeur 1.5).

Map tiles: react-native-maps rendered blank on Android because no Google
Maps key was set. Switched app.json -> app.config.js so
android.config.googleMaps.apiKey is injected from
EXPO_PUBLIC_GOOGLE_API_KEY at build time (keeps the key out of git).
Requires a native rebuild (expo run:android) to take effect.

Also includes the prior payment/auth hardening (server-authoritative
payment_orders ledger with double-spend guards, peppered OTP, register
TOCTOU fix, stats cents fix) that was left uncommitted.

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

lib/use-driver-location.ts

@@ -0,0 +1,105 @@
+import * as Location from "expo-location";
+import { AppState } from "react-native";
+import { useEffect, useRef } from "react";
+
+import { fetchAPI } from "@/lib/fetch";
+
+// While the driver is online, watch their position and POST it to the server
+// as a heartbeat. Each ping both updates the driver's lat/lng and refreshes
+// last_seen/online, which is what keeps the driver eligible for matching. The
+// watch is started when `online` flips true and torn down on false/unmount.
+//
+// The watch must also restart when the app returns to the foreground: the OS
+// suspends location updates in the background, and the subscription we hold
+// does not auto-revive. Without this, a driver who briefly backgrounds the app
+// goes permanently stale (last_seen older than the dispatch freshness window)
+// and stops receiving ride requests until they toggle offline→online again.
+//
+// Pings are throttled to every PING_INTERVAL_MS so a fast-moving driver
+// doesn't hammer the server, and the location permission is only requested
+// once the driver actually intends to go online.
+const PING_INTERVAL_MS = 5000;
+
+export const useDriverLocation = (online: boolean) => {
+  const subscriptionRef = useRef<Location.LocationSubscription | null>(null);
+  const onlineRef = useRef(online);
+  onlineRef.current = online;
+
+  useEffect(() => {
+    if (!online) return;
+
+    let cancelled = false;
+
+    const ping = async (latitude: number, longitude: number) => {
+      try {
+        await fetchAPI("/(api)/driver/location", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ latitude, longitude }),
+        });
+      } catch (error) {
+        // A failed ping is non-fatal — the next one will retry. last_seen
+        // going stale is what takes a driver out of the match pool, not a 500.
+        console.log("[DRIVER_LOCATION_PING]: ", error);
+      }
+    };
+
+    const start = async () => {
+      const { status } = await Location.requestForegroundPermissionsAsync();
+      if (cancelled || status !== "granted") return;
+
+      if (!(await Location.hasServicesEnabledAsync())) return;
+
+      // Seed the server with the last known position immediately, so the
+      // driver is matchable without waiting for the first watch callback.
+      const cached = await Location.getLastKnownPositionAsync({
+        maxAge: 5 * 60 * 1000,
+      });
+      if (!cancelled && cached) {
+        void ping(cached.coords.latitude, cached.coords.longitude);
+      }
+
+      const subscription = await Location.watchPositionAsync(
+        {
+          accuracy: Location.Accuracy.Balanced,
+          timeInterval: PING_INTERVAL_MS,
+          distanceInterval: 20,
+        },
+        ({ coords }) => {
+          if (!cancelled) void ping(coords.latitude, coords.longitude);
+        },
+      );
+
+      if (cancelled) {
+        await subscription.remove();
+        return;
+      }
+      subscriptionRef.current = subscription;
+    };
+
+    const stop = () => {
+      const sub = subscriptionRef.current;
+      subscriptionRef.current = null;
+      void sub?.remove();
+    };
+
+    void start();
+
+    // Restart the watch whenever the app comes back to the foreground. While
+    // backgrounded the OS pauses location updates and the old subscription is
+    // dead; without re-starting it the driver never pings again.
+    const onAppStateChange = (state: string) => {
+      if (state !== "active") return;
+      if (!onlineRef.current) return;
+      stop();
+      if (!cancelled) void start();
+    };
+    const subscription = AppState.addEventListener("change", onAppStateChange);
+
+    return () => {
+      cancelled = true;
+      stop();
+      subscription.remove();
+    };
+  }, [online]);
+};