Refactor MCP tree server: dispatch table, caching, validation, subprocess cleanup

Break up the 1735-line handle_tool match into 45 individual handler functions
with hashtable-based dispatch. Add mtime-based file parse caching (AST + CST),
consolidated run_command helper replacing 9 bare open_process_in patterns,
require_file/require_dir input validation, and pagination (limit/offset) for
sx_find_across, sx_comp_list, sx_comp_usage. Also includes pending VM changes:
rest-arity support, hyperscript parser, compiler/transpiler updates.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

hosts/ocaml/lib/sx_vm.ml

@@ -50,7 +50,7 @@ let jit_compile_ref : (lambda -> (string, value) Hashtbl.t -> vm_closure option)
 (** Sentinel closure indicating JIT compilation was attempted and failed.
     Prevents retrying compilation on every call. *)
 let jit_failed_sentinel = {
-  vm_code = { vc_arity = -1; vc_locals = 0; vc_bytecode = [||]; vc_constants = [||];
+  vm_code = { vc_arity = -1; vc_rest_arity = -1; vc_locals = 0; vc_bytecode = [||]; vc_constants = [||];
               vc_bytecode_list = None; vc_constants_list = None };
   vm_upvalues = [||]; vm_name = Some "__jit_failed__"; vm_env_ref = Hashtbl.create 0; vm_closure_env = None
 }
@@ -142,34 +142,61 @@ let _jit_compiling = ref false
     This is the fast path for intra-VM closure calls. *)
 let push_closure_frame vm cl args =
   let frame = { closure = cl; ip = 0; base = vm.sp; local_cells = Hashtbl.create 4 } in
-  List.iter (fun a -> push vm a) args;
-  for _ = List.length args to cl.vm_code.vc_locals - 1 do push vm Nil done;
+  let rest_arity = cl.vm_code.vc_rest_arity in
+  if rest_arity >= 0 then begin
+    (* &rest function: push positional args, collect remainder into a list.
+       For (fn (a b &rest c) body) with rest_arity=2:
+         slots: 0=a, 1=b, 2=c (the rest list) *)
+    let nargs = List.length args in
+    let rec push_args i = function
+      | [] ->
+        for _ = i to rest_arity - 1 do push vm Nil done;
+        push vm (List [])
+      | a :: remaining ->
+        if i < rest_arity then (push vm a; push_args (i + 1) remaining)
+        else push vm (List (a :: remaining))
+    in
+    push_args 0 args;
+    let used = (if nargs > rest_arity then rest_arity + 1 else nargs + 1) in
+    for _ = used to cl.vm_code.vc_locals - 1 do push vm Nil done
+  end else begin
+    List.iter (fun a -> push vm a) args;
+    for _ = List.length args to cl.vm_code.vc_locals - 1 do push vm Nil done
+  end;
   vm.frames <- frame :: vm.frames
 
 (** Convert compiler output (SX dict) to a vm_code object. *)
 let code_from_value v =
   match v with
   | Dict d ->
-    let bc_list = match Hashtbl.find_opt d "bytecode" with
+    (* Accept both compiler output keys (bytecode/constants/arity) and
+       SX vm-code keys (vc-bytecode/vc-constants/vc-arity) *)
+    let find2 k1 k2 = match Hashtbl.find_opt d k1 with
+      | Some _ as r -> r | None -> Hashtbl.find_opt d k2 in
+    let bc_list = match find2 "bytecode" "vc-bytecode" with
       | Some (List l | ListRef { contents = l }) ->
         Array.of_list (List.map (fun x -> match x with Number n -> int_of_float n | _ -> 0) l)
       | _ -> [||]
     in
-    let entries = match Hashtbl.find_opt d "constants" with
+    let entries = match find2 "constants" "vc-constants" with
       | Some (List l | ListRef { contents = l }) -> Array.of_list l
       | _ -> [||]
     in
     let constants = Array.map (fun entry ->
       match entry with
-      | Dict ed when Hashtbl.mem ed "bytecode" -> entry  (* nested code — convert lazily *)
+      | Dict ed when Hashtbl.mem ed "bytecode" || Hashtbl.mem ed "vc-bytecode" -> entry
       | _ -> entry
     ) entries in
-    let arity = match Hashtbl.find_opt d "arity" with
+    let arity = match find2 "arity" "vc-arity" with
       | Some (Number n) -> int_of_float n | _ -> 0
     in
-    { vc_arity = arity; vc_locals = arity + 16; vc_bytecode = bc_list; vc_constants = constants;
+    let rest_arity = match find2 "rest-arity" "vc-rest-arity" with
+      | Some (Number n) -> int_of_float n | _ -> -1
+    in
+    { vc_arity = arity; vc_rest_arity = rest_arity; vc_locals = arity + 16;
+      vc_bytecode = bc_list; vc_constants = constants;
       vc_bytecode_list = None; vc_constants_list = None }
-  | _ -> { vc_arity = 0; vc_locals = 16; vc_bytecode = [||]; vc_constants = [||];
+  | _ -> { vc_arity = 0; vc_rest_arity = -1; vc_locals = 16; vc_bytecode = [||]; vc_constants = [||];
            vc_bytecode_list = None; vc_constants_list = None }
 
 (** JIT-compile a component or island body.