perf: avoid Tuple2 allocation in OP_%, visitLookup, and OP_in dispatch

[He-Pin]

Motivation

Scala's tuple pattern matching ((visitExpr(a), visitExpr(b)) match { case (X, Y) => ... }) allocates a Tuple2 object on every dispatch. In hot evaluator paths like visitLookup, OP_%, OP_in, OP_==, and OP_!=, this creates millions of short-lived allocations per evaluation. On JVM, the JIT often eliminates these via escape analysis, but on Scala Native, the allocation is real.

Key Design Decision

Replace tuple-based pattern matching with nested match statements:

// Before: allocates Tuple2
(visitExpr(a), visitExpr(b)) match {
  case (X, Y) => ...
}

// After: zero allocation
val l = visitExpr(a)
val r = visitExpr(b)
l match {
  case X => r match { case Y => ... }
  ...
}

Modification

sjsonnet/src/sjsonnet/Evaluator.scala:

• visitLookup: Replaced tuple match on (value, index) with nested match. Checks lhs type first (Arr/Str/Obj), then rhs type (Num/Str).
• OP_%: Replaced (l, r) match with nested match. Checks Num first (most common), then Str for format strings.
• OP_in: Replaced (l, r) match with nested match.
• OP_== / OP_!=: Replaced tuple match with nested match.

All error messages preserved exactly.

Benchmark Results

JMH — Full Suite (35 benchmarks, @fork(1) @WarmUp(1) @measurement(1))

Benchmark	Baseline (ms)	This PR (ms)	Change
bench.02	38.008	35.650	-6.2% ✅
realistic2	76.840	70.214	-8.6% ✅
comparison	20.185	20.009	-0.9%
comparison2	35.769	36.579	+2.3% (noise)
bench.04	0.474	0.474	±0%
foldl	0.271	0.270	±0%

No regressions across all 35 benchmarks.

Analysis

• Functional equivalence: Nested match dispatches to exactly the same code as tuple match. Error messages preserved.
• Allocation savings: Each avoided Tuple2 saves 24 bytes (16-byte object header + 2 reference fields).
• JVM vs Native: On JVM, HotSpot's escape analysis often eliminates Tuple2 allocation. On Scala Native, every Tuple2 is heap-allocated.

References

• Scala Tuple2 allocation overhead: well-documented in Scala performance guides
• Pattern consistent with jrsonnet's enum-based dispatch (no allocations)

Result

Zero-allocation operator dispatch via nested match. No regressions. Eliminates Tuple2 allocation in hot evaluator paths.

[He-Pin]

this is ok in Scala 3.8.x but not for older scala versions, so this is needed.