Merge branch 'ef-rg16a': RG 16(a), RG 111(b), RG 113, and commemoration identity

Closes the largest known-wrong-output item on record (RG 16(a): a Feast
of the Lord occurring on a II-class Sunday leaves the Sunday
uncommemorated -- 5996 wrong days over 1583-9999) together with RG
111(b)'s rank floor on the day it holds, and gives the oracle layer the
ability to compare commemoration identity rather than only presence and
count.

Also corrects a methodological defect that had produced wrong rulings in
both this project and its sibling: docs/research/ holds an electronic
transcription alongside two photographic scans, and the transcription
silently drops commemoration lines -- seven across the year. Reasoning
from its silence had convicted the oracle wrongly on 14 August and
ruled a genuine 9 August commemoration spurious. The scans are the
primary source; the rule is now recorded at the top of the register.

RG 113 replaces an alphabetical same-rank tie-break that had no
rubrical warrant. A bare Commemoratio has no row in RG 91's table at
all, so band no longer hands one the entry of a III-class universal
feast: 4451 days, all four reordered pairs verified against a
photographic scan, zero observed-day changes.

1 files changed, 11 insertions, 8 deletions

diff --git a/test/test_validate.ml b/test/test_validate.ml
index 89053c1..501dd2e 100644
--- a/test/test_validate.ml
+++ b/test/test_validate.ml
@@ -225,7 +225,7 @@ module Synthetic = struct
   let rules : (season, rank) P.rules =
     { P.band = (fun _ _ -> 0);
       disposition = (fun ~winner:_ ~loser:_ -> P.Omit);
-      admit = (fun ~observed:_ _ -> []) }
+      admit = (fun ~observed:_ ~temporal:_ _ -> []) }
 
   let year_start y = match D.make ~year:y ~month:1 ~day:1 with Ok d -> d | Error e -> failwith e
 
@@ -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:_ 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:_ 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
     | [] -> []
@@ -444,9 +446,10 @@ module Synthetic = struct
     { 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:_ cs ->
+        (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:_ 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:_ cs -> cs) }
+      admit = (fun ~observed:_ ~temporal:_ cs -> List.map (fun (c, p, (_ : int)) -> (c, p)) cs) }
 end
 
 open Synthetic