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/payment-orders.ts

@@ -0,0 +1,127 @@
+// Server-authoritative payment order records. The client may never set
+// payment_status or the Areeba successIndicator; both are stored here and
+// verified against the gateway before an order can pay for a ride.
+//
+// A paid order can only be consumed once: consumeOrderForRide atomically
+// flips status 'paid' -> 'consumed', so a single card payment can never buy
+// two rides.
+
+import type { QueryResultRow } from "pg";
+
+import { sql, type SqlValue } from "@/lib/db";
+
+// A tagged-template runner — either the pool-level `sql` helper or the `tx`
+// passed inside a transaction() callback. consumeOrderForRide accepts one so
+// the consume + ride insert can run on a single connection.
+type Runner = <R extends QueryResultRow = QueryResultRow>(
+  strings: TemplateStringsArray,
+  ...values: SqlValue[]
+) => Promise<R[]>;
+
+export type PaymentOrder = {
+  order_id: string;
+  user_id: string;
+  amount_cents: number;
+  currency: string;
+  driver_id: number | null;
+  origin_address: string | null;
+  destination_address: string | null;
+  origin_latitude: number | null;
+  origin_longitude: number | null;
+  destination_latitude: number | null;
+  destination_longitude: number | null;
+  ride_time: number | null;
+  success_indicator: string | null;
+  status: string;
+  created_at: Date;
+  paid_at: Date | null;
+};
+
+export type NewOrder = {
+  order_id: string;
+  user_id: string;
+  amount_cents: number;
+  currency: string;
+  driver_id?: number | null;
+  origin_address?: string | null;
+  destination_address?: string | null;
+  origin_latitude?: number | null;
+  origin_longitude?: number | null;
+  destination_latitude?: number | null;
+  destination_longitude?: number | null;
+  ride_time?: number | null;
+  success_indicator: string | null;
+  status?: string;
+};
+
+export const createOrder = async (order: NewOrder): Promise<PaymentOrder> => {
+  const rows = await sql<PaymentOrder>`
+    INSERT INTO payment_orders (
+      order_id, user_id, amount_cents, currency, driver_id,
+      origin_address, destination_address,
+      origin_latitude, origin_longitude,
+      destination_latitude, destination_longitude,
+      ride_time, success_indicator, status
+    ) VALUES (
+      ${order.order_id},
+      ${order.user_id},
+      ${order.amount_cents},
+      ${order.currency},
+      ${order.driver_id ?? null},
+      ${order.origin_address ?? null},
+      ${order.destination_address ?? null},
+      ${order.origin_latitude ?? null},
+      ${order.origin_longitude ?? null},
+      ${order.destination_latitude ?? null},
+      ${order.destination_longitude ?? null},
+      ${order.ride_time ?? null},
+      ${order.success_indicator},
+      ${order.status ?? "pending"}
+    )
+    RETURNING *
+  `;
+  return rows[0];
+};
+
+export const getOrder = async (orderId: string): Promise<PaymentOrder | null> => {
+  const rows = await sql<PaymentOrder>`
+    SELECT * FROM payment_orders WHERE order_id = ${orderId}
+  `;
+  return rows[0] ?? null;
+};
+
+// Mark an order paid after the gateway confirms capture. The status='pending'
+// guard means an already-paid or consumed order can never be flipped back to
+// 'paid' — this is what prevents a single payment from being resurrected to
+// buy multiple rides (double-spend). verify+api.ts also rejects non-pending
+// orders, so this is defense-in-depth.
+export const markPaid = async (orderId: string): Promise<PaymentOrder | null> => {
+  const rows = await sql<PaymentOrder>`
+    UPDATE payment_orders
+    SET status = 'paid', paid_at = CURRENT_TIMESTAMP
+    WHERE order_id = ${orderId}
+      AND status = 'pending'
+    RETURNING *
+  `;
+  return rows[0] ?? null;
+};
+
+// Atomically consume a paid order for a ride. The WHERE status='paid' guard
+// means a paid order can only be used once; a second attempt gets no row.
+// Pass the transaction `tx` runner so this can run inside ride/create's
+// transaction together with the ride insert.
+export const consumeOrderForRide = async (
+  orderId: string,
+  userId: string,
+  runner: Runner = sql,
+): Promise<PaymentOrder | null> => {
+  const rows = await runner<PaymentOrder>`
+    UPDATE payment_orders
+    SET status = 'consumed'
+    WHERE order_id = ${orderId}
+      AND user_id = ${userId}
+      AND status = 'paid'
+    RETURNING *
+  `;
+  return rows[0] ?? null;
+};