Primitive double sort for numeric arrays in std.sort

Replace Comparator-based java.util.Arrays.sort with primitive double
sort (DualPivotQuicksort) for numeric arrays. Extracts doubles into
primitive array, sorts with intrinsic DualPivotQuicksort, reconstructs
Val.Num array via cachedNum. Eliminates Comparator virtual dispatch
and Double boxing per comparison.

Also optimizes with-key-function path: extracts doubles into primitive
array for unboxed comparison via sortWith instead of boxed sortBy.

Benchmark (bench.06 sort, -f1 -wi12 -i12):
  Before: 5.261 ± 6.115 ms/op
  After:  3.222 ± 0.170 ms/op  (-38.7%)

Regression suite also shows improvement in set operations:
  setDiff:  0.700 → 0.499 ms/op
  setInter: 0.608 → 0.434 ms/op
  setUnion: 0.915 → 0.720 ms/op

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: He-Pin

sjsonnet/src/sjsonnet/stdlib/SetModule.scala

@@ -113,7 +113,11 @@ object SetModule extends AbstractFunctionModule {
           val sortedIndices = if (keyType == classOf[Val.Str]) {
             indices.sortBy(i => keys(i).cast[Val.Str].asString)(Util.CodepointStringOrdering)
           } else if (keyType == classOf[Val.Num]) {
-            indices.sortBy(i => keys(i).cast[Val.Num].asDouble)
+            // Extract doubles into primitive array for unboxed comparison
+            val dkeys = new Array[Double](keys.length)
+            var di = 0
+            while (di < dkeys.length) { dkeys(di) = keys(di).asInstanceOf[Val.Num].asDouble; di += 1 }
+            indices.sortWith((a, b) => dkeys(a) < dkeys(b))
           } else if (keyType == classOf[Val.Arr]) {
             indices.sortBy(i => keys(i).cast[Val.Arr])(ev.compare(_, _))
           } else {
@@ -152,14 +156,15 @@ object SetModule extends AbstractFunctionModule {
                 )
             )
           } else if (keyType == classOf[Val.Num]) {
-            java.util.Arrays.sort(
-              strict.asInstanceOf[Array[AnyRef]],
-              (a: AnyRef, b: AnyRef) =>
-                java.lang.Double.compare(
-                  a.asInstanceOf[Val.Num].asDouble,
-                  b.asInstanceOf[Val.Num].asDouble
-                )
-            )
+            // Primitive double sort: extract doubles, sort primitively (DualPivotQuicksort),
+            // then reconstruct Val.Num array. Avoids Comparator virtual dispatch + boxing.
+            val n = strict.length
+            val doubles = new Array[Double](n)
+            var di = 0
+            while (di < n) { doubles(di) = strict(di).asInstanceOf[Val.Num].asDouble; di += 1 }
+            java.util.Arrays.sort(doubles)
+            di = 0
+            while (di < n) { strict(di) = Val.cachedNum(pos, doubles(di)); di += 1 }
           } else if (keyType == classOf[Val.Arr]) {
             java.util.Arrays.sort(
               strict.asInstanceOf[Array[AnyRef]],