perf(reg-vm): enable DeepCopy elision by default (Phase 2 flip)

Flip RSS_VM_ELIDE_DEEPCOPY default OFF -> ON now that the optimization is proven
parity-preserving and profitable. Unset = elision on; RSS_VM_ELIDE_DEEPCOPY=0
(or off/false/no) restores the byte-identical eager-copy lowering for instant
rollback.

Justification (all with elision active / default):
- runtime 455/0, differential 33/0
- extended generative differential 33/0 @ PROPTEST_CASES=2000 (~25 min fuzzing)
- soak 7/0, cost-model 1/0
- native flat-param telemetry intact (native_call_flat_int/float_param), aliasing
  counter-example held (native_store_reload_mutate_non_mut_heap_param_does_not_leak)
- ~14x on the deep-copy-heavy kernel (deepcopy_read_param.rss: 2.5s -> 0.17s)
- rollback path (elision off) re-verified byte-identical (runtime 455/0)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/reg_vm/model.rs

@@ -1830,21 +1830,24 @@ pub(crate) enum MatchFailurePatch {
 
 /// Process-once gate for compile-time `DeepCopy` elision (`RSS_VM_ELIDE_DEEPCOPY`).
 ///
-/// Default OFF: the lowerer emits every prologue `DeepCopy` exactly as before, so lowering
-/// is byte-identical to the pre-elision compiler. When set to a truthy value the lowerer
-/// neutralizes the `DeepCopy` of any non-`mut` heap parameter it can PROVE is never mutated
-/// through an alias and never escapes the frame — sharing the caller's `Rc` is then
-/// observationally identical to copying it. Read once (like `RSS_JIT_COST_MODEL`) so the
-/// verdict is stable across every function lowering in the process.
+/// Default ON (Phase 2 v2): the lowerer neutralizes the prologue `DeepCopy` of any non-`mut`
+/// heap parameter it can PROVE is never mutated through an alias and never escapes the frame —
+/// sharing the caller's `Rc` is then observationally identical to copying it (the analysis
+/// keeps the copy for everything not proven safe; native sees an unchanged `DeepCopyElided`
+/// marker). Verified parity-preserving over runtime 455/0 + differential 33/0 @ 2000 generative
+/// cases + soak + cost-model, with a ~14x win on the deep-copy-heavy kernel. Set
+/// `RSS_VM_ELIDE_DEEPCOPY=0` (or `off`/`false`/`no`) to restore the byte-identical eager-copy
+/// lowering for a fast rollback. Read once (like `RSS_JIT_COST_MODEL`) so the verdict is stable
+/// across every function lowering in the process.
 fn elide_deepcopy_enabled() -> bool {
     static ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
     *ENABLED.get_or_init(|| {
-        matches!(
+        !matches!(
             std::env::var("RSS_VM_ELIDE_DEEPCOPY")
                 .ok()
                 .as_deref()
                 .map(str::trim),
-            Some("1") | Some("true") | Some("on") | Some("yes")
+            Some("0") | Some("false") | Some("off") | Some("no")
         )
     })
 }