Add inline VM opcodes for hot primitives (OP_ADD through OP_DEC)

16 new opcodes (160-175) bypass the CALL_PRIM hashtable lookup for
the most frequently called primitives:

  Arithmetic: OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_INC, OP_DEC, OP_NEG
  Comparison: OP_EQ, OP_LT, OP_GT, OP_NOT
  Collection: OP_LEN, OP_FIRST, OP_REST, OP_NTH, OP_CONS

The compiler (compiler.sx) recognizes these names at compile time and
emits the inline opcode instead of CALL_PRIM. The opcode is self-
contained — no constant pool index, no argc byte. Each primitive is
a single byte in the bytecode stream.

Implementation in all three VMs:
- OCaml (sx_vm.ml): direct pattern match, no allocation
- SX spec (vm.sx): delegates to existing primitives
- JS (transpiled): same as SX spec

66 new tests in spec/tests/vm-inline.sx covering arithmetic, comparison,
collection ops, composition, and edge cases.

Tests: 1314 JS (full), 1114 OCaml, 32 Playwright

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

hosts/ocaml/lib/sx_vm.ml

@@ -400,6 +400,71 @@ and run vm =
           let v = peek vm in
           Hashtbl.replace vm.globals name v
 
+        (* ---- Inline primitives (no hashtable lookup) ---- *)
+        | 160 (* OP_ADD *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with
+            | Number x, Number y -> Number (x +. y)
+            | String x, String y -> String (x ^ y)
+            | _ -> Sx_primitives.(get_primitive "+" |> function NativeFn (_, f) -> f [a; b] | _ -> Nil))
+        | 161 (* OP_SUB *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Number (x -. y) | _ -> Nil)
+        | 162 (* OP_MUL *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Number (x *. y) | _ -> Nil)
+        | 163 (* OP_DIV *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Number (x /. y) | _ -> Nil)
+        | 164 (* OP_EQ *) ->
+          let b = pop vm and a = pop vm in
+          push vm (Bool (a = b))
+        | 165 (* OP_LT *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Bool (x < y) | String x, String y -> Bool (x < y) | _ -> Bool false)
+        | 166 (* OP_GT *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Bool (x > y) | String x, String y -> Bool (x > y) | _ -> Bool false)
+        | 167 (* OP_NOT *) ->
+          let v = pop vm in
+          push vm (Bool (not (sx_truthy v)))
+        | 168 (* OP_LEN *) ->
+          let v = pop vm in
+          push vm (match v with
+            | List l | ListRef { contents = l } -> Number (float_of_int (List.length l))
+            | String s -> Number (float_of_int (String.length s))
+            | Dict d -> Number (float_of_int (Hashtbl.length d))
+            | Nil -> Number 0.0 | _ -> Number 0.0)
+        | 169 (* OP_FIRST *) ->
+          let v = pop vm in
+          push vm (match v with List (x :: _) | ListRef { contents = x :: _ } -> x | _ -> Nil)
+        | 170 (* OP_REST *) ->
+          let v = pop vm in
+          push vm (match v with List (_ :: xs) | ListRef { contents = _ :: xs } -> List xs | _ -> List [])
+        | 171 (* OP_NTH *) ->
+          let n = pop vm and coll = pop vm in
+          let i = match n with Number f -> int_of_float f | _ -> 0 in
+          push vm (match coll with
+            | List l | ListRef { contents = l } ->
+              (try List.nth l i with _ -> Nil)
+            | _ -> Nil)
+        | 172 (* OP_CONS *) ->
+          let coll = pop vm and x = pop vm in
+          push vm (match coll with
+            | List l -> List (x :: l)
+            | ListRef { contents = l } -> List (x :: l)
+            | Nil -> List [x]
+            | _ -> List [x])
+        | 173 (* OP_NEG *) ->
+          let v = pop vm in
+          push vm (match v with Number x -> Number (-.x) | _ -> Nil)
+        | 174 (* OP_INC *) ->
+          let v = pop vm in
+          push vm (match v with Number x -> Number (x +. 1.0) | _ -> Nil)
+        | 175 (* OP_DEC *) ->
+          let v = pop vm in
+          push vm (match v with Number x -> Number (x -. 1.0) | _ -> Nil)
+
         | opcode ->
           raise (Eval_error (Printf.sprintf "VM: unknown opcode %d at ip=%d"
                                opcode (frame.ip - 1)))