feat: streaming files endpoint + reader pages + chapter pages metadata

Backend:
- Migration 0003_pages.sql adds a `pages` table (id, chapter_id,
  page_number, storage_key, content_type) with a unique (chapter_id,
  page_number). New table because chapter pages can have different MIME
  types per page; reconstructing keys from a single template would
  break the moment a chapter mixes png and jpg pages.
- `domain::Page` + `repo::page` (create + list_for_chapter).
- The chapter upload handler now inserts one page row per part as it
  writes the bytes to storage.
- GET /api/v1/mangas/{id}/chapters/{n}/pages returns `{pages: [...]}`
  with the storage_key clients need to construct image URLs. 404 if
  the manga or chapter doesn't exist; reads are public.

Storage trait grows `get_stream(&str) -> StreamingFile` returning a
`Pin<Box<dyn Stream<Item = io::Result<Bytes>> + Send>>` + size. The
local backend implements via `tokio::fs::File` + `tokio_util::io::
ReaderStream` with a 64 KiB chunk size. GET /api/v1/files/*key now
streams via `axum::body::Body::from_stream` instead of buffering — the
test asserts a 200 KiB file emits >1 frame end-to-end through the
router.

Frontend:
- lib/api/client.ts gains `fileUrl(key)` so components don't
  reconstruct the `/api/v1/files/...` path manually.
- lib/api/chapters.ts gains `ChapterPage` type + `getChapterPages` (the
  type is named ChapterPage to avoid colliding with `Page` from
  client.ts, which is the pagination envelope).
- /manga/[id]/+page.svelte: overview with cover, title, author,
  description, chapter list, and a disabled bookmark control (real
  bookmarking lands in feat/bookmarks). Responsive at 640 px.
- /manga/[id]/chapter/[n]/+page.svelte: paginated reader. Current page
  loads eagerly; next page is preloaded in a hidden img so navigation
  feels instant. Keyboard handler maps ArrowRight/j/Space → next,
  ArrowLeft/k → prev, Home/End → first/last; skips when the user is
  typing in an input. Focus ring on the prev/next buttons.
- SSR is disabled on both routes via `export const ssr = false` so the
  client-only fetch flow doesn't need to be replicated server-side; the
  routes are interactive features, not SEO surfaces.
- E2E (e2e/reader.spec.ts): overview shows the title/cover/chapter
  list; reader pages through three pages via ArrowRight, j, k, and
  ArrowLeft, and the preload img holds the page-2 src on initial load.

Lockstep version bump to 0.6.0.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/tests/api_uploads.rs

@@ -112,6 +112,74 @@ async fn create_manga_rejects_oversized_cover_with_413(pool: PgPool) {
     assert_eq!(body["error"]["code"], "payload_too_large");
 }
 
+#[sqlx::test(migrations = "./migrations")]
+async fn files_endpoint_streams_in_multiple_frames(pool: PgPool) {
+    use axum::http::header;
+    use http_body_util::BodyExt;
+
+    let h = common::harness(pool);
+    let (_, cookie) = common::register_user(&h.app).await;
+    let manga_id = common::seed_manga_via_api(&h.app, &cookie, "Big Manga").await;
+
+    // The test harness caps a single file at 256 KiB; build a ~200 KiB PNG
+    // so it fits but is large enough that the 64 KiB chunker emits >1 frame.
+    let mut big = common::fake_png_bytes();
+    big.resize(200 * 1024, 7);
+
+    let resp = h
+        .app
+        .clone()
+        .oneshot(common::post_multipart_with_cookie(
+            &format!("/api/v1/mangas/{manga_id}/chapters"),
+            common::MultipartBuilder::new()
+                .add_json("metadata", json!({ "number": 1 }))
+                .add_file("page", "1.png", "image/png", &big),
+            &cookie,
+        ))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::CREATED);
+
+    // Fetch the page back via the streaming files endpoint.
+    let pages = h
+        .app
+        .clone()
+        .oneshot(common::get(&format!(
+            "/api/v1/mangas/{manga_id}/chapters/1/pages"
+        )))
+        .await
+        .unwrap();
+    let body = common::body_json(pages).await;
+    let key = body["pages"][0]["storage_key"].as_str().unwrap().to_string();
+
+    let resp = h
+        .app
+        .oneshot(common::get(&format!("/api/v1/files/{key}")))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::OK);
+    assert_eq!(
+        resp.headers().get(header::CONTENT_LENGTH).unwrap(),
+        big.len().to_string().as_str()
+    );
+
+    let mut body = resp.into_body();
+    let mut frames = 0usize;
+    let mut total = 0usize;
+    while let Some(frame) = body.frame().await {
+        let frame = frame.unwrap();
+        if let Some(data) = frame.data_ref() {
+            frames += 1;
+            total += data.len();
+        }
+    }
+    assert_eq!(total, big.len());
+    assert!(
+        frames > 1,
+        "expected the file to stream in more than one frame (got {frames})"
+    );
+}
+
 #[sqlx::test(migrations = "./migrations")]
 async fn create_chapter_with_pages_stores_each(pool: PgPool) {
     let h = common::harness(pool);