Phase 20.12b: quick green + structural cleanup

- Deprecations: add warn-once for nyash.toml (runtime::deprecations); apply in plugin loader v2 (singletons/method_resolver)
- Child env + runner hygiene: unify Stage‑3/quiet/disable-fallback env in test/runner; expand LLVM noise filters
- Docs/branding: prefer  and hako.toml in README.md/README.ja.md and smokes README
- VM: implement Map.clear in MIR interpreter (boxes_map)
- Stage‑B: gate bundle/alias/require smokes behind SMOKES_ENABLE_STAGEB; fix include cwd and resolve() call even for require-only cases
- Core‑Direct: gate rc boundary canary behind SMOKES_ENABLE_CORE_DIRECT
- Smokes: inject Stage‑3 and disable selfhost fallback for LLVM runs; filter using/* logs
- Quick profile: 168/168 PASS locally

This commit accelerates Phase 20.33 (80/20) by stabilizing quick suite, reducing noise, and gating heavy/experimental paths for speed.

src/backend/mir_interpreter/handlers/boxes_map.rs

@@ -121,6 +121,12 @@ pub(super) fn try_handle_map_box(
                     if let Some(d) = dst { this.regs.insert(d, VMValue::from_nyash_box(ret)); }
                     return Ok(true);
                 }
+                "clear" => {
+                    // Reset map to empty; return a neutral value
+                    let ret = mb.clear();
+                    if let Some(d) = dst { this.regs.insert(d, VMValue::from_nyash_box(ret)); }
+                    return Ok(true);
+                }
                 _ => {}
             }
         }

src/backend/mir_interpreter/handlers/boxes_string.rs

@@ -33,6 +33,28 @@ pub(super) fn try_handle_string_box(
                 if let Some(d) = dst { this.regs.insert(d, VMValue::from_nyash_box(ret)); }
                 return Ok(true);
             }
+            "replace" => {
+                // replace(old, new) -> string with first occurrence replaced (Rust replace = all; match Core minimal
+                if args.len() != 2 {
+                    return Err(VMError::InvalidInstruction("replace expects 2 args".into()));
+                }
+                let old_s = this.reg_load(args[0])?.to_string();
+                let new_s = this.reg_load(args[1])?.to_string();
+                // Core policy: replace only the first occurrence
+                let out = if let Some(pos) = sb_norm.value.find(&old_s) {
+                    let mut s = String::with_capacity(sb_norm.value.len() + new_s.len());
+                    s.push_str(&sb_norm.value[..pos]);
+                    s.push_str(&new_s);
+                    s.push_str(&sb_norm.value[pos + old_s.len()..]);
+                    s
+                } else {
+                    sb_norm.value.clone()
+                };
+                if let Some(d) = dst {
+                    this.regs.insert(d, VMValue::from_nyash_box(Box::new(crate::box_trait::StringBox::new(out))));
+                }
+                return Ok(true);
+            }
             "trim" => {
                 let ret = sb_norm.trim();
                 if let Some(d) = dst { this.regs.insert(d, VMValue::from_nyash_box(ret)); }

src/backend/mir_interpreter/handlers/calls.rs

@@ -432,6 +432,17 @@ impl MirInterpreter {
                         ))
                     }
                 }
+                "replace" => {
+                    if args.len() == 2 {
+                        let old = self.reg_load(args[0])?.to_string();
+                        let new = self.reg_load(args[1])?.to_string();
+                        Ok(VMValue::String(s.replace(&old, &new)))
+                    } else {
+                        Err(VMError::InvalidInstruction(
+                            "replace requires 2 arguments".into(),
+                        ))
+                    }
+                }
                 "indexOf" => {
                     if let Some(arg_id) = args.get(0) {
                         let needle = self.reg_load(*arg_id)?.to_string();