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/latest/poller.go

@@ -16,6 +16,11 @@ type Fetcher interface {
 	Get(ctx context.Context, url string) (body string, status int, err error)
 }
 
+// CoverFetcher retrieves one kagane cover through the browser-backed path.
+type CoverFetcher interface {
+	Image(ctx context.Context, imageID string) (body []byte, contentType string, err error)
+}
+
 // Poller re-checks each bookmarked series' newest published chapter on a
 // schedule, independent of the userscript's own in-browser checks. The two run
 // in parallel and report the same observable fact, so whichever writes last wins
@@ -36,7 +41,10 @@ type Poller struct {
 	// BrowserFetch handles sites behind a JavaScript challenge that Fetch
 	// cannot clear. Nil disables those sites entirely rather than falling back
 	// to Fetch, which would only ever retrieve a challenge page.
-	BrowserFetch    Fetcher
+	BrowserFetch Fetcher
+	// CoverFetch is optional: it prefetches kagane covers without changing the
+	// chapter poll's result when the browser or persistence fails.
+	CoverFetch      CoverFetcher
 	Now             func() time.Time // injected so tests can freeze it
 	Cooldown        time.Duration
 	BrowserCooldown time.Duration
@@ -47,6 +55,32 @@ type Poller struct {
 
 var browserBackedSites = []string{"kagane", "novelfull"}
 
+func (p *Poller) prefetchCover(ctx context.Context, sr store.Series) {
+	if sr.Site != "kagane" || p.CoverFetch == nil {
+		return
+	}
+	imageID, ok := store.KaganeImageID(sr.Cover)
+	if !ok {
+		return
+	}
+	_, _, found, err := p.Store.GetKaganeCover(imageID)
+	if err != nil {
+		log.Printf("latest poll %q: read cover: %v", sr.Key(), err)
+		return
+	}
+	if found {
+		return
+	}
+	body, contentType, err := p.CoverFetch.Image(ctx, imageID)
+	if err != nil {
+		log.Printf("latest poll %q: fetch cover: %v", sr.Key(), err)
+		return
+	}
+	if err := p.Store.PutKaganeCover(imageID, body, contentType); err != nil {
+		log.Printf("latest poll %q: persist cover: %v", sr.Key(), err)
+	}
+}
+
 // fetcherFor returns the fetcher a site needs, or nil when the site cannot be
 // fetched at all right now. kagane and novelfull both sit behind a Cloudflare
 // JavaScript challenge that no TLS fingerprint clears — kagane verified
@@ -157,6 +191,7 @@ func (p *Poller) checkOne(ctx context.Context, sr store.Series) {
 		log.Printf("latest poll %q: no fetcher for site %q", sr.Key(), sr.Site)
 		return
 	}
+	p.prefetchCover(ctx, sr)
 
 	body, status, err := f.Get(ctx, sr.SeriesURL)
 	if err != nil {