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/src/api/chapters.rs

@@ -17,19 +17,20 @@ use crate::api::mangas::{next_field, read_field_bytes};
 use crate::api::pagination::PagedResponse;
 use crate::app::AppState;
 use crate::auth::extractor::CurrentUser;
-use crate::domain::Chapter;
 use crate::domain::chapter::NewChapter;
+use crate::domain::{Chapter, Page};
 use crate::error::{AppError, AppResult};
 use crate::repo;
 use crate::upload::{parse_image, UploadedImage};
 
 pub fn routes() -> Router<AppState> {
     Router::new()
-        .route(
-            "/mangas/:manga_id/chapters",
-            get(list).post(create),
-        )
+        .route("/mangas/:manga_id/chapters", get(list).post(create))
         .route("/mangas/:manga_id/chapters/:number", get(get_one))
+        .route(
+            "/mangas/:manga_id/chapters/:number/pages",
+            get(list_pages),
+        )
 }
 
 #[derive(Debug, Deserialize)]
@@ -120,12 +121,14 @@ async fn create(
     .await?;
 
     for (idx, page) in pages.iter().enumerate() {
-        let nnnn = format!("{:04}", idx + 1);
+        let page_number = (idx + 1) as i32;
+        let nnnn = format!("{:04}", page_number);
         let key = format!(
             "mangas/{}/chapters/{}/pages/{}.{}",
             manga_id, chapter.id, nnnn, page.ext
         );
         state.storage.put(&key, &page.bytes).await?;
+        repo::page::create(&state.db, chapter.id, page_number, &key, page.mime).await?;
     }
 
     let page_count = pages.len() as i32;
@@ -138,3 +141,20 @@ async fn create(
 
     Ok((StatusCode::CREATED, Json(chapter)))
 }
+
+#[derive(Debug, serde::Serialize)]
+struct PagesResponse {
+    pages: Vec<Page>,
+}
+
+async fn list_pages(
+    State(state): State<AppState>,
+    Path((manga_id, number)): Path<(Uuid, i32)>,
+) -> AppResult<Json<PagesResponse>> {
+    repo::manga::get(&state.db, manga_id).await?;
+    let chapter = repo::chapter::find_by_manga_and_number(&state.db, manga_id, number)
+        .await?
+        .ok_or(AppError::NotFound)?;
+    let pages = repo::page::list_for_chapter(&state.db, chapter.id).await?;
+    Ok(Json(PagesResponse { pages }))
+}