feat: one recording cut to several songs' lengths is named by AcoustID; the copy in its slot stays, the rest go, and the release is set aside (#6169)

Savant's Mortals held one recording as 16 of its 50 tracks, each trimmed to
its own slot's MusicBrainz length, so the lengths could not say which slot
was its own and every group waited for the operator. When a one-album
mismatch is the same audio (identical, or fingerprints within 0.02) and
every copy fits its own slot, the resolver asks what the recording is: the
copies' own AcoustID lookups, or a fresh lookup of one copy (five a pass).
The track list names each slot's recording; the copy in that slot is kept
and the others removed, or every copy when the recording is in none of
their slots or AcoustID knows none. AcoustID unreachable or answers in
several copies' slots: the group waits.

Whenever wrong-slot copies are removed, the download the files were
imported from is set aside, so the album fetched again is not the same
files. Albums imported before Minstrel downloaded anything have none.

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

internal/library/duplicate_classify_test.go

@@ -113,3 +113,51 @@ func TestWrongSlots(t *testing.T) {
 		}
 	}
 }
+
+// One recording cut to each of several slots' lengths (Savant's Mortals): the
+// lengths cannot place it, and what AcoustID calls it does (#6169).
+func TestTrimmedCopies(t *testing.T) {
+	track := func(title string, ms int32, rec string) dbq.MbReleaseTrack {
+		return dbq.MbReleaseTrack{Title: title, LengthMs: ms, RecordingMbid: rec}
+	}
+	copies := []slotCopy{
+		{Title: "Tormentor", Artist: "The Wombats", DurationMs: 220000},
+		{Title: "Record Shop", Artist: "The Wombats", DurationMs: 181000},
+	}
+	album := []dbq.MbReleaseTrack{
+		track("Tormentor", 221000, "rec-tormentor"), track("Record Shop", 180000, "rec-record-shop"), track("Ice Cream", 200000, "rec-ice"),
+	}
+	if !trimmedToSlots(copies, album) {
+		t.Fatal("each copy fits its own slot: trimmedToSlots should hold the group")
+	}
+	if trimmedToSlots(copies[:1], album) {
+		t.Error("one title is not several songs' slots")
+	}
+	if trimmedToSlots([]slotCopy{copies[0], {Title: "Record Shop", Artist: "The Wombats", DurationMs: 220000}}, album) {
+		t.Error("a copy that does not fit its slot is wrongSlots' to decide")
+	}
+	cases := []struct {
+		name       string
+		tracks     []dbq.MbReleaseTrack
+		recordings []string
+		keep       int
+		losers     []int
+		ok         bool
+	}{
+		{"AcoustID names Tormentor", album, []string{"rec-tormentor"}, 0, []int{1}, true},
+		{"one of several candidates is on the album", album, []string{"rec-elsewhere", "rec-record-shop"}, 1, []int{0}, true},
+		{"AcoustID knows none", album, nil, -1, []int{0, 1}, true},
+		{"the recording is another song on the album", album, []string{"rec-ice"}, -1, []int{0, 1}, true},
+		{"candidates in both copies' slots", album, []string{"rec-tormentor", "rec-record-shop"}, -1, nil, false},
+		{"the track list names no recording for a slot", []dbq.MbReleaseTrack{
+			track("Tormentor", 221000, "rec-tormentor"), track("Record Shop", 180000, ""),
+		}, []string{"rec-tormentor"}, -1, nil, false},
+	}
+	for _, tc := range cases {
+		keep, losers, ok := trimmedCopies(copies, tc.tracks, tc.recordings)
+		if keep != tc.keep || ok != tc.ok || fmt.Sprint(losers) != fmt.Sprint(tc.losers) {
+			t.Errorf("%s: got keep=%d losers=%v ok=%v, want keep=%d losers=%v ok=%v",
+				tc.name, keep, losers, ok, tc.keep, tc.losers, tc.ok)
+		}
+	}
+}