Prefetch Kagane covers during latest polling (#51)

## Summary
- Add an optional browser-backed cover fetcher to the latest-chapter poller.
- Prefetch missing Kagane covers during the existing due-series cycle and persist them before a Reader opens the web UI.
- Keep chapter polling, cooldown stamping, and on-first-view fallback independent from cover failures.

## Behavior and safety
- Stored Kagane covers are detected before browser work, so later poll cycles do not refetch them.
- Nil cover fetchers and non-Kagane series retain the existing behavior.
- Shared Kagane image-id and content-type validation prevents challenge or non-image responses from poisoning persistent cover storage.
- The browser is wired into both the chapter and cover poller paths from the composition root.

## Verification
- `go test ./...`
- Focused latest, store, and web package tests
- Deterministic tests cover missing covers, cached covers, failed fetches, invalid content types, nil fetchers, and non-Kagane series.

Closes #45

Reviewed-on: #51
Co-authored-by: Sulthan Zaki <sultankiki05@gmail.com>
Co-committed-by: Sulthan Zaki <sultankiki05@gmail.com>

backend/internal/store/store.go

@@ -142,14 +142,35 @@ func (b Bookmark) Initial() string {
 // the userscript stores for that site.
 var kaganeCoverRe = regexp.MustCompile(`^https://kagane\.to/api/v2/image/([0-9a-f-]{36})/compressed$`)
 
+// KaganeImageID extracts the validated image id from the cover URL recorded by
+// the userscript.
+func KaganeImageID(cover string) (string, bool) {
+	m := kaganeCoverRe.FindStringSubmatch(cover)
+	if m == nil {
+		return "", false
+	}
+	return m[1], true
+}
+
+// IsKaganeCoverContentType reports whether a fetched response is safe to store
+// and serve as a cover.
+func IsKaganeCoverContentType(contentType string) bool {
+	switch contentType {
+	case "image/webp", "image/jpeg", "image/png", "image/avif", "image/gif":
+		return true
+	default:
+		return false
+	}
+}
+
 // CoverURL is the src the web UI puts in an <img>. For every site but kagane
 // that is Cover as stored. kagane serves its images behind a Cloudflare
 // challenge *and* with `cross-origin-resource-policy: same-origin`, so no page
 // on another origin can load one however it asks (verified 2026-08-08); those
 // go through the backend's own proxy instead.
 func (b Bookmark) CoverURL() string {
-	if m := kaganeCoverRe.FindStringSubmatch(b.Cover); m != nil {
-		return "/img/kagane/" + m[1]
+	if imageID, ok := KaganeImageID(b.Cover); ok {
+		return "/img/kagane/" + imageID
 	}
 	return b.Cover
 }
@@ -551,6 +572,9 @@ func (s *Store) GetKaganeCover(imageID string) ([]byte, string, bool, error) {
 // PutKaganeCover persists one fetched cover. Image ids are immutable, so a
 // later fetch cannot replace the bytes already made durable.
 func (s *Store) PutKaganeCover(imageID string, body []byte, contentType string) error {
+	if !IsKaganeCoverContentType(contentType) {
+		return fmt.Errorf("put kagane cover %q: unsupported content type %q", imageID, contentType)
+	}
 	if _, err := s.db.Exec(`
 		INSERT INTO covers (image_id, body, content_type)
 		VALUES ($1, $2, $3)