Add phone-relay dashcam upload to bypass the Pi's slow WiFi

Root-caused the slow-upload complaint to the Pi's own congested 2.4GHz
WiFi radio (confirmed via iperf3 - same degraded throughput even on
pure local LAN traffic, ruling out Cloudflare/ISP). Since the Pi 3 B
has no 5GHz radio, add a way to bypass it for the internet-bound leg:
a phone opens /dash and manually relays pending dashcam files straight
to the remote server over its own network, reusing the exact same
chunked upload protocol the Pi's client already uses.

- server/app.py: add CORS headers (after_request) so the phone's
  browser can call the remote server cross-origin from a page served
  by the Pi.
- app.py: new endpoints - GET /api/dash/pending (list not-yet-uploaded
  files), GET /api/dash/file/<path> (Range-request-capable download,
  path-traversal safe), GET /api/dash/relay/config (hands the phone
  the device credentials), POST /api/dash/relay/heartbeat|stop (lease-
  based pause of the Pi's own background uploader, self-heals if the
  phone's tab closes uncleanly), POST /api/dash/relay/mark_uploaded.
- modules/app_upload.py: list_pending_dashcam_files(), relay lease
  helpers, _upload_dashcam_files() now pauses while a relay lease is
  active.
- modules/app_sql.py: new dashcam_hash_cache table so a file's sha256
  is only computed once (keyed by path+size+mtime) instead of being
  recomputed on every loop iteration/pending-list call - benefits the
  existing background uploader too.
- templates/dash.html / static/js/dash.js: new "Relay via phone" card
  - per-file and "relay all" buttons (manual trigger only, per user
  preference), downloads+uploads one 40MB slice at a time so the
  phone never holds a whole file in memory, retries chunks up to 3x.
- PLAN.md/readme.md/server/README.md updated (Phase 11).

Tested via a full local end-to-end simulation driving the real Pi and
server Flask apps side by side (Postgres mocked only at the db module
boundary - all HTTP/chunking/auth/CORS logic is real): verified Range
downloads (206), byte-for-byte reassembly via SHA256, path-traversal
rejection, and the relay lease correctly pausing/resuming the
background uploader. Not yet tested against a real phone/live network.

server/README.md

@@ -28,6 +28,14 @@ headers: `X-Device-Name` and `X-Api-Key` (see
 Postgres is **not** published to the LAN — only the `api` container talks to
 it, over the internal compose network.
 
+**CORS is enabled on every response** (`Access-Control-Allow-Origin: *`) so a
+device's registered API key can be used directly from browser JS running on a
+*different* origin — specifically, the Pi's phone-relay feature (see
+[PLAN.md](../PLAN.md) Phase 11), where a phone's browser calls this API
+straight from a page served by the Pi itself. This is safe here because
+auth is header-based (`X-Device-Name`/`X-Api-Key`), not cookie/session-based,
+so a permissive origin can't be used to steal a logged-in session.
+
 ## Deploying on unraid
 
 1. Get the code onto the unraid box (same repo as the Pi, just the

server/app.py

@@ -12,6 +12,20 @@ from modules.auth import require_device_auth
 
 app = Flask(__name__)
 
+# The phone-relay feature (Pi web UI) has a phone's browser call this API
+# directly from a page served BY THE PI (a different origin than this
+# server), so the browser enforces CORS on those cross-origin requests.
+# Wildcard is fine here - this API is authenticated via the X-Device-Name/
+# X-Api-Key headers (not cookies), so there's no session/credential to leak
+# via a permissive Access-Control-Allow-Origin.
+@app.after_request
+def _add_cors_headers(response):
+    response.headers["Access-Control-Allow-Origin"] = "*"
+    response.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+    response.headers["Access-Control-Allow-Headers"] = "Content-Type, X-Device-Name, X-Api-Key"
+    response.headers["Access-Control-Max-Age"] = "600"
+    return response
+
 # Where uploaded dashcam files get written on disk (mounted to the unraid
 # array via docker-compose - see DASHCAM_STORAGE_DIR in .env).
 STORAGE_DIR = os.environ.get("DASHCAM_STORAGE_DIR", "/data/dashcam")