iter ext-rename: .ailx → .ail across the live toolchain

The surface-form file extension changes from .ailx to .ail. AILang's
authoring surface now uses the same .ail stem as its canonical JSON
form (.ail.json), giving the language a single coherent extension
family: .ail is the LLM-authored Form A, .ail.json is the canonical
JSON-AST Form B.

Scope (touched):
- 61 example renames examples/**/*.ailx → .ail (git mv)
- 1 rename experiments/.../rendered/ailx.md → ail.md
- 35 content-edited live-toolchain files (crates/, docs/DESIGN.md,
  docs/roadmap.md, docs/PROSE_ROUNDTRIP.md, skills/, bench/reference/*.c,
  experiment crates under experiments/.../{render,harness,master})
- Experiment-crate cohort rename Cohort::Ailx → Cohort::Ail,
  Form::Ailx → Form::Ail, per_cohort/ailx → per_cohort/ail,
  {form-only: ailx} → {form-only: ail}, ```ailx → ```ail

Out of scope (deliberately untouched, to preserve honest history):
- docs/journal-archive.md (content-frozen per CLAUDE.md)
- docs/journals/, docs/specs/, docs/plans/, bench/orchestrator-stats/
- experiments/.../runs/ (frozen LLM-output artefacts; models actually
  saw .ailx — renaming would falsify the experimental record)

Verification: cargo build/test --workspace green; experiment crate
cargo test green; bench/check.py + compile_check.py + cross_lang.py
all 0-regressed; negative grep for ailx|Ailx|AILX outside the
out-of-scope paths returns zero matches.

Opens immediate follow-up: roadmap.md P2 todo `ail check`/build/run
accept .ail extension — after this rename, .ail is canonical
authoring surface but the CLI still produces a misleading JSON-parse
error on `ail check foo.ail`. That's the next iter.

crates/ail/src/main.rs

@@ -190,7 +190,7 @@ enum Cmd {
         #[arg(long)]
         json: bool,
     },
-    /// Parses a `.ailx` source file (form (A)) into canonical
+    /// Parses a `.ail` source file (form (A)) into canonical
     /// `.ail.json`. Iter 14c addition; symmetric to `render`.
     ///
     /// The form-(A) projection is one of potentially many producers of
@@ -269,7 +269,7 @@ fn compose_merge_prose_prompt(original_form_a: &str, edited_prose: &str) -> Stri
         "You are integrating prose edits back into an AILang module.
 
 ROLE
-Your job is to produce an updated AILang module in Form-A (an .ailx
+Your job is to produce an updated AILang module in Form-A (an .ail
 file) that reflects the human's prose edits while preserving the
 load-bearing semantic detail from the original module.
 
@@ -826,7 +826,7 @@ fn main() -> Result<()> {
             }
         }
         Cmd::Parse { path, output } => {
-            // Read .ailx, parse via the surface crate, emit canonical
+            // Read .ail, parse via the surface crate, emit canonical
             // JSON. Symmetric to `render` (which goes the other way).
             let src = std::fs::read_to_string(&path)
                 .with_context(|| format!("reading {}", path.display()))?;

crates/ail/tests/e2e.rs

@@ -429,8 +429,8 @@ fn render_parse_round_trip_canonical() {
         .expect("run ail render");
     assert!(render.status.success(), "ail render failed");
 
-    let tmp = std::env::temp_dir().join(format!("ailang_render_e2e_{}.ailx", std::process::id()));
-    std::fs::write(&tmp, &render.stdout).expect("write rendered ailx");
+    let tmp = std::env::temp_dir().join(format!("ailang_render_e2e_{}.ail", std::process::id()));
+    std::fs::write(&tmp, &render.stdout).expect("write rendered ail");
 
     let parsed = Command::new(ail_bin())
         .args(["parse", tmp.to_str().unwrap()])
@@ -2153,7 +2153,7 @@ fn build_and_run_with_rc_stats(example: &str) -> (String, u64, u64, i64) {
 /// not leak the LCons outer cells.
 ///
 /// Background: 18f.2's tail-latency bench found that
-/// `bench_latency_explicit.ailx` peaks at the same RSS as the
+/// `bench_latency_explicit.ail` peaks at the same RSS as the
 /// implicit-mode variant despite carrying mode annotations
 /// throughout the hot path. Diagnosis: in
 ///

crates/ail/tests/roundtrip_cli.rs

@@ -62,7 +62,7 @@ fn roundtrip_one(fixture: &Path, tmpdir: &Path) -> Result<(), String> {
     let bytes_orig = ailang_core::canonical::to_bytes(&original_module);
     let h_orig = blake3::hash(&bytes_orig);
 
-    // Step B: `ail render <fixture>` → captured stdout = ailx text.
+    // Step B: `ail render <fixture>` → captured stdout = ail text.
     let render_out = Command::new(ail_bin())
         .args(["render", fixture.to_str().unwrap()])
         .output()
@@ -75,20 +75,20 @@ fn roundtrip_one(fixture: &Path, tmpdir: &Path) -> Result<(), String> {
         ));
     }
 
-    // Step C: write the rendered .ailx into the tempdir.
+    // Step C: write the rendered .ail into the tempdir.
     let stem = fixture
         .file_name()
         .and_then(|n| n.to_str())
         .and_then(|n| n.strip_suffix(".ail.json"))
         .unwrap_or("fixture");
-    let tmp_ailx = tmpdir.join(format!("{stem}.round.ailx"));
-    std::fs::write(&tmp_ailx, &render_out.stdout)
-        .map_err(|e| format!("write tempfile {}: {e}", tmp_ailx.display()))?;
+    let tmp_ail = tmpdir.join(format!("{stem}.round.ail"));
+    std::fs::write(&tmp_ail, &render_out.stdout)
+        .map_err(|e| format!("write tempfile {}: {e}", tmp_ail.display()))?;
 
-    // Step D: `ail parse <tmp_ailx>` → captured stdout = canonical
+    // Step D: `ail parse <tmp_ail>` → captured stdout = canonical
     //         bytes + trailing newline.
     let parse_out = Command::new(ail_bin())
-        .args(["parse", tmp_ailx.to_str().unwrap()])
+        .args(["parse", tmp_ail.to_str().unwrap()])
         .output()
         .map_err(|e| format!("spawn ail parse: {e}"))?;
     if !parse_out.status.success() {