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/files.rs

@@ -1,7 +1,11 @@
-//! Serves blobs from the `Storage` trait. Same endpoint serves manga
-//! covers and chapter pages; the key embedded in the URL is whatever
-//! the writer stored.
+//! Streams blobs from the `Storage` trait. Same endpoint serves manga
+//! covers and chapter pages; the key embedded in the URL is whatever the
+//! writer stored.
+//!
+//! The handler uses `Storage::get_stream` so a multi-MB page is piped to
+//! the client a chunk at a time instead of buffered server-side.
 
+use axum::body::Body;
 use axum::extract::{Path, State};
 use axum::http::header;
 use axum::response::{IntoResponse, Response};
@@ -17,13 +21,17 @@ pub fn routes() -> Router<AppState> {
 }
 
 async fn serve(State(state): State<AppState>, Path(key): Path<String>) -> AppResult<Response> {
-    let bytes = match state.storage.get(&key).await {
-        Ok(b) => b,
+    let file = match state.storage.get_stream(&key).await {
+        Ok(f) => f,
         Err(StorageError::NotFound) => return Err(crate::error::AppError::NotFound),
         Err(e) => return Err(e.into()),
     };
     let ct = content_type_for(&key);
-    Ok(([(header::CONTENT_TYPE, ct)], bytes).into_response())
+    let headers = [
+        (header::CONTENT_TYPE, ct.to_string()),
+        (header::CONTENT_LENGTH, file.size_bytes.to_string()),
+    ];
+    Ok((headers, Body::from_stream(file.stream)).into_response())
 }
 
 fn content_type_for(key: &str) -> &'static str {