Merge branch 'fix/ef-precedence-defects': seven EF calendar defects

Fixes seven defects in the EF calendar, each found by differential and
oracle comparison against an independently-written engine and each
backed by a cited paragraph of the Rubricae Generales verified against
the 1962 Missal:

  RG 96  transfers must skip II-class days (the Precious Blood was
         landing on the Visitation)
  RG 91  a II-class privileged feria yields to an equal-class feast
         (St Matthew was losing to the September Ember Wednesday)
  RG 11  all Sundays of Advent, Lent and Passiontide are I class
         (only Advent I was), which also settles St Joseph on a Lent
         Sunday
  RG 131 Rose on Gaudete and Laetare, which the EF path never emitted
  RG 122 Holy Thursday is white

and the sanctoral generator itself, whose rank inference had tagged 15
III-class feasts as commemorations, dropped four entries to slug
collisions, and mis-tagged three class fields.

The EF oracle test asserted Season only, which is why none of this ever
failed. It now asserts rank and colour, with a cited allow-list.

Two commemorations had been deleted on a primary-source claim the
primary source contradicts: the Archivum Liturgicum transcription
silently drops commemoration lines where the photographic scans carry
them. Six of the seven affected dates are now present; the seventh
(25 December) is blocked by an ingestion limit that reads only the
first of three Christmas Masses, recorded at its cause.

Known gap, recorded in source: RG 95/97/98 chained transfers, where two
I-class feasts translate to the same day.

1 files changed, 58 insertions, 9 deletions

diff --git a/internal/calendar/precedence_ef_test.go b/internal/calendar/precedence_ef_test.go
index 818b452..d5e254f 100644
--- a/internal/calendar/precedence_ef_test.go
+++ b/internal/calendar/precedence_ef_test.go
@@ -6,6 +6,14 @@ func efCand(rank Rank, temporal bool) candidate {
 	return candidate{Cel: Celebration{Rank: rank}, Temporal: temporal}
 }
 
+// efTemporalCand builds a temporal candidate with the season/Sunday flags
+// precedenceEF's tie-break actually reads, so a test claiming to exercise
+// "a Sunday" or "a Lenten feria" genuinely sets those fields rather than
+// happening to pass for an unrelated reason (e.g. a class difference alone).
+func efTemporalCand(rank Rank, season Season, sunday bool) candidate {
+	return candidate{Cel: Celebration{Rank: rank}, Temporal: true, Season: season, Sunday: sunday}
+}
+
 func TestPrecedenceEF(t *testing.T) {
 	c1 := efCand(RankClass1, false)
 	c3 := efCand(RankClass3, false)
@@ -14,16 +22,57 @@ func TestPrecedenceEF(t *testing.T) {
 	if !(precedenceEF(c1) < precedenceEF(c3) && precedenceEF(c3) < precedenceEF(c4) && precedenceEF(c4) < precedenceEF(comm)) {
 		t.Error("EF class ordering broken (class-1 > class-3 > class-4 > commemoration)")
 	}
-	// at equal class, the temporal office wins.
-	temp := efCand(RankClass2, true)
+	// a I-class feast beats a II-class Sunday (RG 91 entry 11 vs entry 15 --
+	// different classes, so this holds regardless of the tie-break, but the
+	// candidate is still marked Sunday so the test means what its name says).
+	sunday2 := efTemporalCand(RankClass2, TimeAfterPentecost, true)
+	feast1 := efCand(RankClass1, false)
+	obs, others := pickEF([]candidate{sunday2, feast1})
+	if obs.Cel.Rank != RankClass1 || len(others) != 1 {
+		t.Errorf("I-class feast should win over II-class Sunday, got %+v", obs.Cel)
+	}
+}
+
+// TestPrecedenceEFClass2SundayVsFeria: RG 91 entries 15/16/18 -- at class 2,
+// a SUNDAY wins its tie against an equal-class feast (entry 15 above 16), but
+// a privileged FERIA (the Ember days, the late-Advent 17-23 Dec ferias, entry
+// 18) YIELDS to one (entry 16 above 18) -- the opposite of the Sunday case.
+// This is defect 2's own witness: before the fix, precedenceEF treated every
+// non-ordinaryFeria temporal candidate the same way, so an Ember/late-Advent
+// feria wrongly won its tie exactly like a Sunday does.
+func TestPrecedenceEFClass2SundayVsFeria(t *testing.T) {
 	saint := efCand(RankClass2, false)
-	obs, _ := pickEF([]candidate{saint, temp})
-	if !obs.Temporal {
-		t.Error("equal-class: temporal office should be observed")
+
+	sunday := efTemporalCand(RankClass2, TimeAfterPentecost, true)
+	obsSunday, _ := pickEF([]candidate{saint, sunday})
+	if !obsSunday.Temporal {
+		t.Errorf("a II-class Sunday should win its tie against an equal-class feast, got %+v observed", obsSunday.Cel)
 	}
-	// a I-class feast beats a II-class Sunday.
-	obs2, others := pickEF([]candidate{efCand(RankClass2, true), efCand(RankClass1, false)})
-	if obs2.Cel.Rank != RankClass1 || len(others) != 1 {
-		t.Errorf("I-class feast should win over II-class Sunday, got %+v", obs2.Cel)
+
+	emberFeria := efTemporalCand(RankClass2, TimeAfterPentecost, false) // e.g. the September Ember Wednesday
+	obsFeria, _ := pickEF([]candidate{saint, emberFeria})
+	if obsFeria.Temporal {
+		t.Errorf("a II-class privileged feria should yield its tie to an equal-class feast, got %+v observed (temporal)", obsFeria.Cel)
+	}
+}
+
+// TestPrecedenceEFClass3FeriaSeason: the pre-existing rule (unchanged by
+// defect 2's fix), stated explicitly rather than left implicit: an ORDINARY
+// III/IV-class feria (per annum, Advent to 16 Dec, Septuagesima) yields to an
+// equal-class feast; the ferias of Lent and Passiontide are privileged and
+// win instead.
+func TestPrecedenceEFClass3FeriaSeason(t *testing.T) {
+	saint := efCand(RankClass3, false)
+
+	ordinary := efTemporalCand(RankClass3, Advent, false)
+	obsOrdinary, _ := pickEF([]candidate{saint, ordinary})
+	if obsOrdinary.Temporal {
+		t.Errorf("an ordinary Advent feria should yield to an equal-class feast, got %+v observed (temporal)", obsOrdinary.Cel)
+	}
+
+	lenten := efTemporalCand(RankClass3, Lent, false)
+	obsLenten, _ := pickEF([]candidate{saint, lenten})
+	if !obsLenten.Temporal {
+		t.Errorf("a Lenten feria should win its tie against an equal-class feast, got %+v observed", obsLenten.Cel)
 	}
 }