fix(vm): partial equals() fix - pointer equality support

Partial fix for VM equality comparison bug. Adds infrastructure for
semantic equality but keeps user-defined equals() dispatch disabled.

**What This Fixes**:
- ✅ Primitive comparisons (int, string, bool) - unchanged, still work
- ✅ Pointer equality (same instance) - fast path with Arc::ptr_eq
- ✅ VoidBox/MissingBox special cases - handled correctly
- ✅ Infrastructure for eval_equals() method dispatch

**What's Still Broken**:
- ❌ User-defined equals() methods - dispatch disabled (line 61: if false)
- ❌ Box semantic equality - falls back to reference inequality

**Root Cause** (from investigation):
- Bug is NOT in eval.rs:224 (Compare instruction)
- Bug is in abi_util.rs:75 (eq_vm uses Arc::ptr_eq for ALL boxes)
- Calling exec_function_inner() from eval_cmp() causes re-entrant stack overflow

**Next Steps** (root fix required):
- Option 1: Transform `box1 == box2` → `box1.equals(box2)` at MIR level
- Option 2: Use existing BoxCall mechanism instead of Compare instruction
- Option 3: Deferred execution queue to avoid re-entrant calls

**Files Modified**:
- src/backend/mir_interpreter/helpers/eval.rs
  - Added eval_equals() method (lines 23-77)
  - Modified eval_cmp() to take &mut self (line 209)
  - Changed Compare Eq/Ne to use eval_equals() (lines 306-307)
  - Added InstanceBox, Arc imports

**Test Results**:
- ✅ Primitives: ALL PASS
- ✅ Pointer equality: PASS
- ❌ User-defined equals(): DISABLED (would stack overflow)

**Issue**: This is a PARTIAL fix. Full semantic equality requires root fix.
See: docs/development/issues/equals-stack-overflow.md

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: nyash-codex

src/backend/mir_interpreter/helpers/eval.rs

@@ -1,7 +1,9 @@
 use super::super::*;
 use crate::backend::mir_interpreter::VmConfig;
 use crate::box_trait::VoidBox;
+use crate::instance_v2::InstanceBox;
 use std::string::String as StdString;
+use std::sync::Arc;
 
 impl MirInterpreter {
     #[inline]
@@ -18,6 +20,62 @@ impl MirInterpreter {
         }
     }
 
+    /// Smart equality comparison that supports user-defined equals() methods.
+    ///
+    /// Strategy:
+    /// 1. Fast path: Pointer equality for same instance (Arc::ptr_eq)
+    /// 2. Smart path: Call user-defined equals() method if exists
+    /// 3. Fallback: Reference inequality for different instances
+    /// 4. Special cases: VoidBox/MissingBox comparisons
+    pub(in crate::backend::mir_interpreter) fn eval_equals(
+        &mut self,
+        a: &VMValue,
+        b: &VMValue
+    ) -> Result<bool, VMError> {
+        use VMValue::*;
+
+        match (a, b) {
+            (BoxRef(ax), BoxRef(bx)) => {
+                // Fast path: pointer equality short-circuit
+                if Arc::ptr_eq(ax, bx) {
+                    return Ok(true);
+                }
+
+                // VoidBox special case - treat as equal to each other
+                let a_is_void = ax.as_any().downcast_ref::<VoidBox>().is_some();
+                let b_is_void = bx.as_any().downcast_ref::<VoidBox>().is_some();
+                if a_is_void && b_is_void {
+                    return Ok(true);
+                }
+
+                // MissingBox special case - treat as equal to each other
+                let a_is_missing = ax.as_any().downcast_ref::<crate::boxes::missing_box::MissingBox>().is_some();
+                let b_is_missing = bx.as_any().downcast_ref::<crate::boxes::missing_box::MissingBox>().is_some();
+                if a_is_missing && b_is_missing {
+                    return Ok(true);
+                }
+
+                // TODO: Method dispatch for InstanceBox with user-defined equals()
+                // Temporarily disabled due to stack overflow issue - needs investigation
+                // See: https://github.com/hakorune/hakorune/issues/XXX
+                if false {
+                    if let Some(inst) = ax.as_any().downcast_ref::<InstanceBox>() {
+                        let class_name = &inst.class_name;
+                        let method_sig = format!("{}.equals/1", class_name);
+                        if let Some(_func) = self.functions.get(&method_sig) {
+                            eprintln!("[vm-warn] equals() method found for {} but dispatch is disabled", class_name);
+                        }
+                    }
+                }
+
+                // Fallback: different instances without equals() method
+                Ok(false)
+            }
+            // Primitives and other types: use existing eq_vm logic
+            _ => Ok(eq_vm(a, b))
+        }
+    }
+
     pub(in crate::backend::mir_interpreter) fn reg_load(&self, id: ValueId) -> Result<VMValue, VMError> {
         match self.regs.get(&id).cloned() {
             Some(v) => Ok(v),
@@ -124,7 +182,7 @@ impl MirInterpreter {
         })
     }
 
-    pub(in crate::backend::mir_interpreter) fn eval_cmp(&self, op: CompareOp, a: VMValue, b: VMValue) -> Result<bool, VMError> {
+    pub(in crate::backend::mir_interpreter) fn eval_cmp(&mut self, op: CompareOp, a: VMValue, b: VMValue) -> Result<bool, VMError> {
         use CompareOp::*;
         use VMValue::*;
         // Dev-time: normalize BoxRef(VoidBox) → VMValue::Void when tolerance is enabled or in --dev.
@@ -221,8 +279,8 @@ impl MirInterpreter {
         } else { (a4.clone(), b4.clone()) };
 
         let result = match (op, &a5, &b5) {
-            (Eq, _, _) => eq_vm(&a5, &b5),
-            (Ne, _, _) => !eq_vm(&a5, &b5),
+            (Eq, _, _) => self.eval_equals(&a5, &b5)?,
+            (Ne, _, _) => !self.eval_equals(&a5, &b5)?,
             (Lt, Integer(x), Integer(y)) => x < y,
             (Le, Integer(x), Integer(y)) => x <= y,
             (Gt, Integer(x), Integer(y)) => x > y,