Add alternative names and cover art for soundtracks

Alternative names (#32):
- PUT /api/v1/soundtracks/{uuid}/alternative-names replaces a soundtrack's
  alternative names (trimmed, deduplicated, without the soundtrack's own name).
- alternative_names is in the soundtrack and statistics responses.
- /find matches them too and shows which name matched.

Covers (#12), stored in COVERS_PATH and off when it is not set:
- GET, PUT (upload) and DELETE /api/v1/soundtracks/{uuid}/cover, and
  PUT .../cover/source to pick a SteamGridDB game or AniList anime by ID.
  Uploaded and picked covers are never replaced automatically.
- With STEAMGRIDDB_API_KEY, a background job searches SteamGridDB, then
  AniList, by name, alternative names and the name without bracketed parts,
  at startup, after a sync and after names change. Search results are ranked
  by matching words, so "Civilization IV" gets "Sid Meier's Civilization IV".
- cover_modified (Unix seconds) is in the soundtrack and statistics responses,
  so clients can cache covers.

The new columns are added to migration 000006, which is not released yet.

Closes #12, closes #32

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

cmd/web/search_test.go

@@ -28,8 +28,24 @@ var soundtracks = []string{
 	"Ys III - Wanderers from Ys (+The Oath in Felghana)",
 }
 
-func newCache(names []string) *backend.SearchCache {
-	return backend.NewSearchCache(func(context.Context) ([]string, error) { return names, nil })
+func newCache(names []string, alternatives ...map[string][]string) *backend.SearchCache {
+	soundtracks := make([]backend.SearchSoundtrack, len(names))
+	for i, name := range names {
+		soundtracks[i] = backend.SearchSoundtrack{Name: name}
+		for _, a := range alternatives {
+			soundtracks[i].AlternativeNames = a[name]
+		}
+	}
+	return backend.NewSearchCache(func(context.Context) ([]backend.SearchSoundtrack, error) { return soundtracks, nil })
+}
+
+// names returns the soundtrack names of results.
+func names(results []SearchResult) []string {
+	var n []string
+	for _, r := range results {
+		n = append(n, r.Name)
+	}
+	return n
 }
 
 func searchData(t *testing.T) []backend.SoundtrackData {
@@ -62,23 +78,50 @@ func TestSearch(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.query, func(t *testing.T) {
-			assert.Equal(t, tt.want, search(tt.query, data))
+			assert.Equal(t, tt.want, names(search(tt.query, data)))
 		})
 	}
 }
 
 func TestSearchEmptyReturnsEverything(t *testing.T) {
-	assert.Equal(t, soundtracks, search("", searchData(t)))
+	assert.Equal(t, soundtracks, names(search("", searchData(t))))
 }
 
 func TestSearchOrdering(t *testing.T) {
 	// "MG" is an exact match, "Metal Gear Solid..." only matches by letters in order.
-	results := search("mg", searchData(t))
+	results := names(search("mg", searchData(t)))
 	require.GreaterOrEqual(t, len(results), 2)
 	assert.Equal(t, "MG", results[0])
 	assert.Contains(t, results, "Metal Gear Solid 4 - Guns of the Patriots")
 }
 
+func TestSearchAlternativeNames(t *testing.T) {
+	data, err := newCache(soundtracks, map[string][]string{
+		"Final Fantasy VII": {"FF7", "ファイナルファンタジーVII"},
+		"Kingdom Hearts":    {"KH"},
+	}).Get(context.Background())
+	require.NoError(t, err)
+
+	assert.Equal(t, []SearchResult{{Name: "Final Fantasy VII", MatchedName: "FF7"}}, search("ff7", data))
+	assert.Equal(t, []SearchResult{{Name: "Final Fantasy VII", MatchedName: "ファイナルファンタジーVII"}}, search("ファイナル", data))
+	assert.Equal(t, []SearchResult{{Name: "Final Fantasy VII"}}, search("fantasy", data),
+		"no matched name when the soundtrack's own name matches")
+	// An exact match on an alternative name comes before a letters-in-order match on a name.
+	results := search("kh", data)
+	require.NotEmpty(t, results)
+	assert.Equal(t, SearchResult{Name: "Kingdom Hearts", MatchedName: "KH"}, results[0])
+}
+
+func TestFoundSoundtracksShowsMatchedName(t *testing.T) {
+	var out strings.Builder
+	require.NoError(t, FoundSoundtracks([]SearchResult{
+		{Name: "Final Fantasy VII", MatchedName: "FF7"}, {Name: "Kingdom Hearts"},
+	}).Render(context.Background(), &out))
+	assert.Contains(t, out.String(), "Final Fantasy VII")
+	assert.Contains(t, out.String(), "Also known as FF7")
+	assert.Equal(t, 1, strings.Count(out.String(), "Also known as"))
+}
+
 func TestSearchHandler(t *testing.T) {
 	handler := NewSearchHandler(newCache(soundtracks))
 	req := httptest.NewRequest(http.MethodPost, "/find", strings.NewReader(url.Values{"search_term": {"kingdom"}}.Encode()))
@@ -93,7 +136,7 @@ func TestSearchHandler(t *testing.T) {
 }
 
 func TestSearchHandlerLoadError(t *testing.T) {
-	cache := backend.NewSearchCache(func(context.Context) ([]string, error) { return nil, errors.New("db down") })
+	cache := backend.NewSearchCache(func(context.Context) ([]backend.SearchSoundtrack, error) { return nil, errors.New("db down") })
 	rec := httptest.NewRecorder()
 	NewSearchHandler(cache).ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/find", nil))
 	assert.Equal(t, http.StatusInternalServerError, rec.Code)