perf(frontend): make the lists and grids pay per row, not per library

A list pays per row, and only while scrolling — and none of this is
visible to any test tier: nothing renders differently and nothing
fails, the app is just slower.

- The track list's Art column rendered `CoverArtPath`, the original
  artwork, into a 24 px box while `CoverArtSmall` sat unused on the
  same model, with no `loading="lazy"`. 26 of 26 image requests asked
  for the full-size tier; now 0.
- `artists-view`'s avatar fallback linear-scanned every cached album
  per card per frame, lowercasing two strings per comparison, inside
  the virtualizer's renderItem — the common case, since a locally
  tagged library has no artist images at all. Measured at 5 000 albums
  and 24 visible cards: 1.46 ms/frame -> 0.01 ms/frame.
- Five components resolved selected file paths back to tracks with
  `tracks.find(...)`; they share `utils/track-index.ts` now. "Select
  all -> Edit tags" at 50 000 tracks: 3 051-6 298 ms -> 68 ms.
- "Play this artist", "play these albums" and the album drag cache
  resolve paths in one call instead of one per album.
- The column-resize drag registers its document listeners on mousedown.

Two things here are load-bearing and read as sloppiness. The per-render
arrow functions in `artists-view` and `genres-view` are the *only*
thing changing a property of their virtualizer on a host update, and
therefore the only thing repainting the cards: hoisting them to stable
fields takes a selection from 1 highlighted card to 0. And a row inside
a virtualizer needs `width: 100%`, because the virtualizer positions
its children absolutely and a grid row otherwise shrinks to fit its
content and stops lining up with the header above it.

frontend/src/components/cover-grid/album-selection.ts

@@ -1,6 +1,7 @@
 import {
     GetAlbumTracks,
     GetAlbumTracksByLibrary,
+    GetFilePathsByAlbums,
 } from '@go/library/Library';
 import { libraryStore } from '@store/library-store';
 import type { library } from '@go/models';
@@ -62,6 +63,31 @@ export class AlbumSelectionManager {
             : GetAlbumTracks(albumId);
     }
 
+    /**
+     * File paths for several albums in one call, keyed
+     * by album id.
+     *
+     * perf.m2: every caller below used to loop over the
+     * albums awaiting `GetAlbumTracks` per album, so
+     * Ctrl+A over 5 000 albums was 5 000 sequential
+     * round trips — each returning whole track rows to
+     * read one field off them.
+     */
+    private async fetchAlbumPaths(
+        albumIds: Iterable<number>,
+    ): Promise<Record<number, string[]>> {
+        const ids = Array.from(albumIds).filter((id) =>
+            this.albumById.has(id),
+        );
+
+        if (ids.length === 0) return {};
+
+        const libId =
+            libraryStore.getSelectedLibraryId();
+
+        return GetFilePathsByAlbums(ids, libId ?? 0);
+    }
+
     // ================================================================
     // Album selection helpers
     // ================================================================
@@ -99,19 +125,25 @@ export class AlbumSelectionManager {
     async getSelectedAlbumFilePaths(
         selectedAlbums: Set<number>,
     ): Promise<string[]> {
-        const allPaths: string[] = [];
+        try {
+            const byAlbum = await this.fetchAlbumPaths(
+                selectedAlbums,
+            );
+            const allPaths: string[] = [];
 
-        for (const id of selectedAlbums) {
-            const album = this.albumById.get(id);
+            for (const id of selectedAlbums) {
+                allPaths.push(...(byAlbum[id] ?? []));
+            }
 
-            if (!album) continue;
+            return allPaths;
+        } catch (error) {
+            console.error(
+                'Error loading album tracks:',
+                error,
+            );
 
-            const paths =
-                await this.getAlbumFilePaths(album);
-            allPaths.push(...paths);
+            return [];
         }
-
-        return allPaths;
     }
 
     /**
@@ -182,32 +214,30 @@ export class AlbumSelectionManager {
     async warmCache(
         selectedAlbums: Set<number>,
     ): Promise<void> {
-        for (const id of selectedAlbums) {
-            if (this.albumFilePathCache.has(id)) {
-                continue;
-            }
+        const missing = [...selectedAlbums].filter(
+            (id) => !this.albumFilePathCache.has(id),
+        );
 
-            const album = this.albumById.get(id);
+        try {
+            const byAlbum =
+                await this.fetchAlbumPaths(missing);
 
-            if (!album) continue;
+            for (const id of missing) {
+                const paths = byAlbum[id];
 
-            try {
-                const tracks =
-                    await this.fetchAlbumTracks(
-                        album.ID,
-                    );
-
-                // Only store if still selected.
-                if (selectedAlbums.has(album.ID)) {
+                // Only store if still selected: the
+                // selection can have moved on while
+                // this was in flight.
+                if (paths && selectedAlbums.has(id)) {
                     this.albumFilePathCache.set(
-                        album.ID,
-                        tracks.map((t) => t.FilePath),
+                        id,
+                        paths,
                     );
                 }
-            } catch {
-                // Silently skip — drag will just not
-                // include this album's paths.
             }
+        } catch {
+            // Silently skip — drag will just not
+            // include these albums' paths.
         }
 
         // Prune stale entries (6h).