fix(kernel,rite-ef): admit orders commemorations by RG 113's table of precedence, not slug

Precedence_ef.admit broke a same-rank tie among commemoration candidates
alphabetically by slug -- a deterministic engineering convention with no
rubrical citation. RG 113's own second sentence, primary-source-verified
against two independent scans and previously uncited in the register
(only "commemoratio de Tempore fit primo loco" was quoted before), gives
the real rule: "in admittendis et ordinandis aliis commemorationibus,
servetur ordo tabellae praecedentiae" -- admitting and ordering
commemorations both run on the rite's own table of precedence (band's
28-entry table), not RG 8's coarse four-class rank.

Precedence.resolve now computes each commemoration candidate's own band
value once, generically, and hands it to rules.admit as a third tuple
element (Precedence.rules.admit's signature changed accordingly, ditto
Precedence_ef.admit; every rule-record stub in the test suite updated to
match). Precedence_ef.admit's own compare_dignity is replaced by
compare_precedence, ordering by band then slug; a residual tie within one
identical band value still falls back to slug, since RG 113 gives no
further instruction there -- documented as a still-uncited engineering
convention, not dressed up as a rubric.

RG 98 ("in paritate autem Officium prius impeditum praecedit") was
considered as a candidate authority for that residual and rejected: it
governs the transfer queue order among several simultaneously-impeded
I-class feasts (Caput XIII), a different operation in a different
chapter from RG 113's commemoration admission (Caput XVI); nothing in the
primary text connects the two.

Blast radius measured against the pre-change binary across the entire
1583-9999 domain (not only 2005-2050): the admitted-commemoration-slug
set is byte-identical, day for day, before and after this change. The
fix corrects the citation and mechanism, not the answer, on this
codebase's current data -- both of the task brief's named examples
(22 Feb Chair-of-Peter/Lent-vs-Paul, 22 Sept Maurice-vs-Thomas-of-
Villanova) are confirmed present and unchanged in both streams. A new
test (RG113: admit picks by precedence order, not slug, when they
disagree) proves admit actually consults the passed-in precedence value
with a synthetic pair whose slug order and precedence order disagree --
teeth a same-band-only regression test could not have caught, since
every real collision found in the domain happens to agree on both axes.

271 -> 272 tests, all green; COLITUR_EXHAUSTIVE_SWEEP=1 unaffected.

1 files changed, 9 insertions, 6 deletions

diff --git a/test/test_validate.ml b/test/test_validate.ml
index 42c58f5..501dd2e 100644
--- a/test/test_validate.ml
+++ b/test/test_validate.ml
@@ -377,7 +377,9 @@ module Synthetic = struct
   let dup_rules : (season, rank) P.rules =
     { P.band = (fun _ c -> match c.P.origin with P.Temporal -> 0 | P.Sanctoral -> 10);
       disposition = (fun ~winner:_ ~loser:_ -> P.Commemorate P.Ordinary);
-      admit = (fun ~observed:_ ~temporal:_ cs -> List.map (fun (c, p) -> ({ c with P.origin = c.P.origin }, p)) cs) }
+      admit =
+        (fun ~observed:_ ~temporal:_ cs ->
+          List.map (fun (c, p, (_ : int)) -> ({ c with P.origin = c.P.origin }, p)) cs) }
 
   (* "unconverged": two entries collide on one date (6 June), both beating
      the temporal office and tied with each other, so slug decides:
@@ -416,7 +418,7 @@ module Synthetic = struct
       disposition =
         (fun ~winner:_ ~loser ->
           match loser.P.cel.Cel.rank with R1 -> P.Transfer | R2 -> P.Commemorate P.Ordinary);
-      admit = (fun ~observed:_ ~temporal:_ cs -> cs) }
+      admit = (fun ~observed:_ ~temporal:_ cs -> List.map (fun (c, p, (_ : int)) -> (c, p)) cs) }
 
   let guard_transfer_target (_ : rank P.candidate) (origin : D.t) (_ : D.t -> rank Cel.t) = origin
 
@@ -434,7 +436,7 @@ module Synthetic = struct
   let adm_c_entry = mk_entry ~month:9 ~day:9 ~slug:"adm-c" ~rank:R2
   let adm_layer = Layer.of_entries ~id:"adm" ~name:"adm" [ adm_a_entry; adm_b_entry; adm_c_entry ]
 
-  let adm_compare_slug (c1, _) (c2, _) = Slug.compare c1.P.cel.Cel.slug c2.P.cel.Cel.slug
+  let adm_compare_slug (c1, _, _) (c2, _, _) = Slug.compare c1.P.cel.Cel.slug c2.P.cel.Cel.slug
 
   let rec adm_take n = function
     | [] -> []
@@ -446,7 +448,8 @@ module Synthetic = struct
       admit =
         (fun ~observed:_ ~temporal:_ cs ->
           let sorted = List.stable_sort adm_compare_slug cs in
-          if List.length sorted mod 2 = 1 then adm_take 2 sorted else adm_take 1 sorted) }
+          let taken = if List.length sorted mod 2 = 1 then adm_take 2 sorted else adm_take 1 sorted in
+          List.map (fun (c, p, (_ : int)) -> (c, p)) taken) }
 
   (* "observed": two DIFFERENT layer entries sharing one slug -- a realistic
      data mistake (a renamed or duplicated entry), not prevented by
@@ -475,7 +478,7 @@ module Synthetic = struct
       disposition =
         (fun ~winner:_ ~loser ->
           match loser.P.cel.Cel.rank with R1 -> P.Transfer | R2 -> P.Commemorate P.Ordinary);
-      admit = (fun ~observed:_ ~temporal:_ cs -> cs) }
+      admit = (fun ~observed:_ ~temporal:_ cs -> List.map (fun (c, p, (_ : int)) -> (c, p)) cs) }
 
   let collide_d2 = match D.make ~year:2026 ~month:2 ~day:10 with Ok d -> d | Error e -> failwith e
   let collide_transfer_target (_ : rank P.candidate) (_ : D.t) (_ : D.t -> rank Cel.t) = collide_d2
@@ -492,7 +495,7 @@ module Synthetic = struct
   let clean_sanctoral_rules : (season, rank) P.rules =
     { P.band = (fun _ c -> match c.P.origin with P.Temporal -> 0 | P.Sanctoral -> 10);
       disposition = (fun ~winner:_ ~loser:_ -> P.Commemorate P.Ordinary);
-      admit = (fun ~observed:_ ~temporal:_ cs -> cs) }
+      admit = (fun ~observed:_ ~temporal:_ cs -> List.map (fun (c, p, (_ : int)) -> (c, p)) cs) }
 end
 
 open Synthetic