precedence_ef: a II-class privileged feria yields to a feast (defect 2)

precedenceEF's equal-class tie-break only distinguished "ordinary
III/IV-class feria yields" from "everything else wins" -- Sundays,
named feasts, Lent/Passiontide ferias, AND II-class privileged ferias
(the Ember days, the late-Advent 17-23 Dec ferias) were all bucketed
into the same "wins its tie" branch. RG 91 disagrees at class 2:
entry 15 (Sundays) sits ABOVE entry 16 (II-class feasts of the
universal Church), so a Sunday wins -- but entry 16 sits ABOVE entry
18 (II-class ferias, including the Ember days), so those FERIAS
yield instead, the opposite direction from a Sunday. St Matthew (21
September, II class) was losing to the September Ember Wednesday
every time the two coincided; St Thomas (21 December, II class) was
losing to an ordinary late-Advent feria the same way once the
previous commit correctly promoted those ferias to II class.

The fix distinguishes a II-class Sunday from a II-class feria using a
Sunday flag that already existed on `candidate` (used by the OF path)
but was never wired up for EF: temporal_ef.go's efCel always set
Sunday: false, even on an actual Sunday. A new efSunday helper (efCel
plus the flag) replaces the three efCel calls inside temporalEF's
Sunday branch, and computeEF now propagates td.Sunday into the day's
temporal candidate.

precedence_ef_test.go's own pre-existing witness ("at equal class, the
temporal office wins") encoded exactly the bug: a bare class-2
temporal candidate with no Sunday/season information, standing in for
"the temporal office" in general. It is rewritten into two explicit
cases (Sunday wins its tie; a privileged feria yields) plus the
existing Lent/Passiontide-vs-ordinary III/IV-class case restated
explicitly rather than left implicit.

Witness (precedence_ef_repro_test.go): TestMatthewBeatsSeptemberEmberWednesday.
Fails before this commit with:
  2016-09-21 observed = "ef-september-ember-wed" want matthew (RG 91
    entry 16 beats entry 18)
  2022-09-21 observed = "ef-september-ember-wed" want matthew (RG 91
    entry 16 beats entry 18)

With this commit, all seven named defects are fixed:
LECTIO_EF_ORACLE_STRICT=1 go test ./internal/calendar/... -run TestOracleEF
passes (0 unallow-listed rank/colour mismatches over 730 days). The
gate stays in place for this commit; a following commit removes it.

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)
 	}
 }