chore: throwaway mode-migration tool for the Implicit cutover (#55, 0121 task 3)

Adds `ail migrate-modes <file>` (a throwaway CLI subcommand) and the AST
walker `ailang_core::ast::for_each_fn_type_mut` it drives: parse a .ail,
map every bare/Implicit fn-type slot to Own, preserve explicit
Own/Borrow, print back. Semantically invisible today (PartialEq treats
Implicit == Own), but it materialises the modes so the post-cutover
parser — which will reject bare slots — accepts the migrated corpus.

Both are throwaway: removed in task 4 once ParamMode::Implicit is
deleted (the closure references Implicit and would not compile).
RED-first: migrate_modes.rs failed to compile (missing walker) before
for_each_fn_type_mut was added. Additive; full workspace suite green.

refs #55

crates/ail/src/main.rs

@@ -76,6 +76,10 @@ enum Cmd {
     /// `render | parse` reproduces the input's canonical bytes
     /// (gated by `crates/ailang-surface/tests/round_trip.rs`).
     Render { path: PathBuf },
+    /// THROWAWAY (spec 0062): rewrite every bare fn-type slot in a
+    /// `.ail` file as `(own …)`, preserving explicit `(own)`/`(borrow)`.
+    /// Removed in the Implicit-deletion cutover.
+    MigrateModes { path: PathBuf },
     /// Prints a single definition as JSON or pretty text.
     Describe {
         path: PathBuf,
@@ -440,6 +444,22 @@ fn main() -> Result<()> {
             let m = ailang_surface::load_module(&path)?;
             print!("{}", ailang_surface::print(&m));
         }
+        Cmd::MigrateModes { path } => {
+            let src = std::fs::read_to_string(&path)?;
+            let mut m = ailang_surface::parse(&src)?;
+            ailang_core::ast::for_each_fn_type_mut(&mut m, &mut |n, pm, rm| {
+                pm.resize(n, ailang_core::ast::ParamMode::Own);
+                for x in pm.iter_mut() {
+                    if matches!(x, ailang_core::ast::ParamMode::Implicit) {
+                        *x = ailang_core::ast::ParamMode::Own;
+                    }
+                }
+                if matches!(rm, ailang_core::ast::ParamMode::Implicit) {
+                    *rm = ailang_core::ast::ParamMode::Own;
+                }
+            });
+            std::fs::write(&path, ailang_surface::print(&m))?;
+        }
         Cmd::Prose { path } => {
             // load via `load_module` (single-module mode,
             // matching how `render` / `parse` work). Workspace-wide