fix(recommendation): artist-level arms take one track per related artist in turn (#5297)

The similar_artists and coplay_artists arms ordered by artist score, so the
closest related artist's catalogue filled the whole LIMIT. On the operator's
library the 30-row similar_artists arm held exactly one artist for all 17
seeds measured (#3879), though each seed had 7-33 similar artists in the
library. Both arms now rank tracks within each artist and take every
artist's first track, best artist first, before anyone's second.

Both also skip missing tracks: the outer select already dropped them, but
only after they had taken places in the arm's LIMIT.

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

internal/recommendation/candidates_v2_test.go

@@ -429,3 +429,69 @@ func TestLoadCandidatesFromSimilarity_DifferentSeedsCanDrawDifferently(t *testin
 			"varying with the seed at all", len(seen))
 	}
 }
+
+// #5297: an artist-level arm takes a track from each related artist before a
+// second from any. Ordered by artist score alone, the closest artist's
+// catalogue filled the whole LIMIT; on the operator's library the
+// similar_artists arm held one artist for every seed measured (#3879).
+func TestLoadCandidatesFromSimilarity_ArtistArmsRoundRobin(t *testing.T) {
+	for _, source := range []string{"listenbrainz", "user_cooccurrence"} {
+		t.Run(source, func(t *testing.T) {
+			f := newFixture(t, 1)
+			ctx := context.Background()
+			seed := f.tracks[0]
+			artistOf := map[[16]byte]string{}
+			for i, score := range []float64{0.9, 0.8, 0.7} {
+				name := fmt.Sprintf("Related %d", i)
+				ar, err := f.q.UpsertArtist(ctx, dbq.UpsertArtistParams{Name: name, SortName: name})
+				if err != nil {
+					t.Fatal(err)
+				}
+				al, err := f.q.UpsertAlbum(ctx, dbq.UpsertAlbumParams{Title: name, SortTitle: name, ArtistID: ar.ID})
+				if err != nil {
+					t.Fatal(err)
+				}
+				// More tracks per artist than the arm's limit, so the closest
+				// artist alone could fill it.
+				for j := 0; j < 5; j++ {
+					tr, err := f.q.UpsertTrack(ctx, dbq.UpsertTrackParams{
+						Title: fmt.Sprintf("%s #%d", name, j), AlbumID: al.ID, ArtistID: ar.ID,
+						FilePath: fmt.Sprintf("/tmp/related-%d-%d.flac", i, j), DurationMs: 180_000,
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					artistOf[tr.ID.Bytes] = name
+				}
+				if _, err := f.pool.Exec(ctx,
+					`INSERT INTO artist_similarity (artist_a_id, artist_b_id, score, source) VALUES ($1, $2, $3, $4)`,
+					seed.ArtistID, ar.ID, score, source); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			limits := CandidateSourceLimits{}
+			if source == "listenbrainz" {
+				limits.SimilarArtist = 3
+			} else {
+				limits.UserCoplay = 3
+			}
+			got, err := LoadCandidatesFromSimilarity(
+				ctx, f.q, f.user, seed.ID, 1, SessionVector{Seed: true}, nil, limits, "test-seed",
+			)
+			if err != nil {
+				t.Fatalf("load: %v", err)
+			}
+			artists := map[string]int{}
+			for _, c := range got {
+				if name, ok := artistOf[c.Track.ID.Bytes]; ok {
+					artists[name]++
+				}
+			}
+			if len(got) != 3 || len(artists) != 3 {
+				t.Errorf("arm of 3 drew %d candidates from %d related artists (%v), want one from each of 3",
+					len(got), len(artists), artists)
+			}
+		})
+	}
+}