iter it.2: structural-guardedness checker + first real Diverge effect

Iteration-discipline milestone, 2 of 3. Strictly additive (nothing
tail-related removed; that is it.3). New whole-body pass
verify_structural_recursion sibling of verify_tail_positions
(DD-1): smaller-set algorithm with implicit candidate inference +
unconstrained accumulators (DD-2, foldl=structural), self/mutual
via inline ADT-family union-find (DD-3), it.2-only tail==false
grandfather. CheckError::NonStructuralRecursion. term_contains_loop
(stops at Term::Lam, DD-4) injects Diverge so existing
UndeclaredEffect enforces it, no new variant; lam-arrow + LetRec
sub-effect sites wired. DESIGN.md Decision 3 synced. Four it.1
loop fixtures gained !Diverge.

Two spec-premise boundary defects surfaced + resolved within the
additive invariant (corpus clean, check not weakened), recorded as
corrected it.3 corpus-migration scope: (1) the "21 tail-app
fixtures" grandfather premise under-counts the corpus —
no-ADT-candidate counter recursions have no structural position to
verify, deferred to it.3; (2) two RC-regression fixtures joined the
spec's transitional tail-app grandfather as the other 20 do (RC==GC
guards verified still green). cargo test --workspace 622/0; 9
acceptance pins non-vacuous. Spec fda9b78, plan bc9f512.

examples/struct_rec_sum_e2e.ail

@@ -0,0 +1,41 @@
+; Iter it.2 Phase-3 e2e: an it.2-clean structural recursion that
+; actually RUNS. `sum` recurses on the Cons-tail `t` via a plain,
+; non-tail `(app sum t)` — structurally guarded ⇒ the it.2 check
+; classifies it pure + total, so it carries NO `!Diverge` and uses
+; NO `tail-app` marker. This proves the structural-recursion
+; classification is behaviourally sound end-to-end (the "total"
+; verdict is not just a typecheck assertion): build [1,2,3,4,5],
+; sum it structurally, print 15.
+
+(module struct_rec_sum_e2e
+
+  (data IntList
+    (ctor INil)
+    (ctor ICons (con Int) (con IntList)))
+
+  (fn sum
+    (doc "Structural sum: plain non-tail recursion on the Cons tail. No !Diverge, no tail-app.")
+    (type
+      (fn-type
+        (params (con IntList))
+        (ret (con Int))))
+    (params xs)
+    (body
+      (match xs
+        (case (pat-ctor INil) 0)
+        (case (pat-ctor ICons h t)
+          (app + h (app sum t))))))
+
+  (fn main
+    (doc "Build [1,2,3,4,5] and print its structural sum. Expected stdout: 15.")
+    (type (fn-type (params) (ret (con Unit)) (effects IO)))
+    (params)
+    (body
+      (app print
+        (app sum
+          (term-ctor IntList ICons 1
+            (term-ctor IntList ICons 2
+              (term-ctor IntList ICons 3
+                (term-ctor IntList ICons 4
+                  (term-ctor IntList ICons 5
+                    (term-ctor IntList INil)))))))))))