perf: O(1) sort and equality for range arrays

[He-Pin]

Summary

O(1) fast paths for sorting and comparing range arrays. std.sort(std.range(1, N)) previously materialized the full range into an array and performed O(n log n) sort on already-sorted data. Now returns immediately. std.assertEqual on two equal ranges similarly drops from O(n) element comparison to O(1).

Changes

1. Sort fast path for range arrays — sortArr checks Val.Arr.asSortedIfKnown(pos) before materializing. Forward ranges return as-is (already sorted ascending); reversed ranges return the O(1) forward equivalent via the existing reversed() method. Only applies when no keyF is provided; falls through to full sort otherwise.

2. Range equality fast path — Evaluator.equal for two Val.Arr adds two short-circuits before element-by-element comparison:

   • Reference equality (x eq y) — covers assertEqual(r, sort(r)) where sort returns the same object
   • Structural range equality (rangeEquals) — covers assertEqual(range(1,N), sort(reverse(range(1,N)))) where both sides are ranges with the same (rangeFrom, length, reversed)

Both optimizations use semantic methods on Val.Arr (asSortedIfKnown, rangeEquals) that encapsulate range internals — callers never access _isRange or _rangeFrom directly.

Benchmark Results — Scala Native vs jrsonnet (Rust, from source)

Machine: Apple Silicon, macOS. Tool: hyperfine --warmup 5 --min-runs 30 -N.

Reliable benchmarks (>20ms runtime, startup overhead not dominant)

Benchmark	master (ms)	this PR (ms)	jrsonnet (ms)	PR vs master	PR vs jrsonnet
comparsion_for_primitives	35	35	211	~neutral	6.0x faster
inheritance_recursion	62	61	121	~neutral	2.0x faster
simple_recursive_call	29	29	52	~neutral	1.8x faster
realistic_2	85	85	98	~neutral	1.16x faster

Sub-20ms benchmarks (startup noise significant)

Benchmark	master (ms)	this PR (ms)	jrsonnet (ms)	PR vs master	PR vs jrsonnet
realistic_1	10.6	10.9	13.7	~neutral	1.3x faster
foldl_string_concat	6.5	6.5	9.6	~neutral	1.5x faster
std_foldl	6.4	6.0	7.0	~neutral	~tied
array_sorts	7.6	7.6	5.3	~neutral	startup gap

Note on sub-10ms benchmarks: Scala Native process startup is ~3-4ms vs Rust ~1ms. For benchmarks with <10ms total runtime, this 2-3ms difference is 40-60% of measured time and masks algorithmic improvements. The sort/equality fast paths eliminate O(n log n) sort and O(n) comparison for range arrays, but the absolute savings (microseconds) are invisible in wall-clock time at this scale.

Algorithmic improvement

Operation	Before	After
std.sort(std.range(1, N))	O(n) materialize + O(n log n) sort	O(1)
std.sort(std.reverse(std.range(1, N)))	O(n) materialize + O(n log n) sort	O(1)
assertEqual(range_a, range_b) same sequence	O(n) element comparison	O(1)
assertEqual(x, x) same object	O(n) element comparison	O(1)

Test plan

• ./mill 'sjsonnet.jvm[3.3.7]'.test — all 141 test suites pass
• ./mill __.reformat — scalafmt passes
• ./mill 'sjsonnet.native[3.3.7]'.nativeLink — Native binary builds
• No regressions on any benchmark

[He-Pin]

would be better do with patterns after 778