perf: eliminate redundant ThreadLocal.get and copyInto$default calls

Pass PointScratch through mulDoubleG instead of re-fetching from
ThreadLocal. The verify path was calling ThreadLocal.get() 2x:
once in verifySchnorrFast and again in mulDoubleG. On ART, each
ThreadLocal.get costs ~41µs (hash table probe), totaling ~83µs
per verify (~1% of total).

mulDoubleG now accepts an optional PointScratch parameter
(defaults to scratch.get() for backward compat). The verify
path passes its already-fetched scratch through.

Also fix all remaining LongArray copyInto calls with default params:
- MutablePoint.copyFrom: 3 calls per copy (x, y, z)
- MutablePoint.setAffine: 2 calls (x, y)
- mulDoubleG P-table build: 2 calls per table entry
- mul P-table build: 2 calls per table entry
- batchToAffine: 2 calls
- U256.copyInto: was delegating with defaults

Each copyInto$default adds a bitmask check + 3 branches + arraylength
per call. With ~13 LongArray copies per verify, this eliminates ~52
extra branch instructions from the hot path.

https://claude.ai/code/session_015CtM5k88rF7WFgX8o2AGNR

quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/utils/secp256k1/ECPoint.kt

@@ -154,7 +154,7 @@ internal object ECPoint {
         // Step 1: compute prefix products of Z coordinates
         // prods[i] = z[0] * z[1] * ... * z[i]
         val prods = Array(n) { LongArray(4) }
-        jac[0].z.copyInto(prods[0])
+        jac[0].z.copyInto(prods[0], 0, 0, 4)
         for (i in 1 until n) {
             FieldP.mul(prods[i], prods[i - 1], jac[i].z)
         }
@@ -483,8 +483,8 @@ internal object ECPoint {
         val pLamOddJac = s.pLamOddJac
         for (i in 0 until tableSize) {
             FieldP.mul(pLamOddJac[i].x, pOddJac[i].x, Glv.BETA, s.w)
-            pOddJac[i].y.copyInto(pLamOddJac[i].y)
-            pOddJac[i].z.copyInto(pLamOddJac[i].z)
+            pOddJac[i].y.copyInto(pLamOddJac[i].y, 0, 0, 4)
+            pOddJac[i].z.copyInto(pLamOddJac[i].z, 0, 0, 4)
         }
 
         // Effective-affine: batch-convert with shared Z inversion
@@ -598,8 +598,8 @@ internal object ECPoint {
         s: LongArray,
         p: MutablePoint,
         e: LongArray,
+        sc: PointScratch = scratch.get(),
     ) {
-        val sc = scratch.get()
         val wP = 5 // Window for P-side (table built per-call, keep small)
         val pTableSize = 1 shl (wP - 2) // 8 entries for P
 
@@ -641,8 +641,8 @@ internal object ECPoint {
             val pLamOddJac = sc.pLamOddJac
             for (i in 0 until pTableSize) {
                 FieldP.mul(pLamOddJac[i].x, pOddJac[i].x, Glv.BETA, sc.w)
-                pOddJac[i].y.copyInto(pLamOddJac[i].y)
-                pOddJac[i].z.copyInto(pLamOddJac[i].z)
+                pOddJac[i].y.copyInto(pLamOddJac[i].y, 0, 0, 4)
+                pOddJac[i].z.copyInto(pLamOddJac[i].z, 0, 0, 4)
             }
             // Batch-convert to affine (into scratch arrays)
             batchToAffinePair(pOddJac, pLamOddJac, sc.pOddAff, sc.pLamOddAff, sc)
@@ -872,7 +872,7 @@ internal object ECPoint {
 
         // Build prefix products of Z (shared between a and b)
         val cumZ = s.cumZ
-        a[0].z.copyInto(cumZ[0])
+        a[0].z.copyInto(cumZ[0], 0, 0, 4)
         for (i in 1 until n) {
             FieldP.mul(cumZ[i], cumZ[i - 1], a[i].z, w)
         }

quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/utils/secp256k1/PointTypes.kt

@@ -58,17 +58,17 @@ internal class MutablePoint(
     }
 
     fun copyFrom(other: MutablePoint) {
-        other.x.copyInto(x)
-        other.y.copyInto(y)
-        other.z.copyInto(z)
+        other.x.copyInto(x, 0, 0, 4)
+        other.y.copyInto(y, 0, 0, 4)
+        other.z.copyInto(z, 0, 0, 4)
     }
 
     fun setAffine(
         ax: LongArray,
         ay: LongArray,
     ) {
-        ax.copyInto(x)
-        ay.copyInto(y)
+        ax.copyInto(x, 0, 0, 4)
+        ay.copyInto(y, 0, 0, 4)
         z[0] = 1L
         for (i in 1 until 4) z[i] = 0L
     }

quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/utils/secp256k1/Secp256k1.kt

@@ -506,7 +506,7 @@ object Secp256k1 {
         // Q = s·G + (-e)·P via Shamir's trick
         ScalarN.negTo(e, e) // negate in-place
         sc.entryPoint.setAffine(sc.entryPx, sc.entryPy) // copies px/py, so entryPx is free
-        ECPoint.mulDoubleG(sc.entryResult, s, sc.entryPoint, e)
+        ECPoint.mulDoubleG(sc.entryResult, s, sc.entryPoint, e, sc)
 
         if (sc.entryResult.isInfinity()) return false
 

quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/utils/secp256k1/U256.kt

@@ -602,6 +602,6 @@ internal object U256 {
         out: LongArray,
         a: LongArray,
     ) {
-        a.copyInto(out)
+        a.copyInto(out, 0, 0, 4)
     }
 }