Ottimizza il kernel GPU: ~2x throughput sulla Quadro P4000

Tre modifiche, tutte a parità di risultato (verificate end-to-end):

- Ammortamento della moltiplicazione scalare: prima scalar_mult_basic
  (l'operazione di gran lunga più costosa) veniva rieseguita a ogni
  batch, cioè 40 volte per kernel launch. Ora viene eseguita UNA sola
  volta per launch; il punto base P0 viene poi fatto avanzare di
  GPU_EC_BATCH_SIZE*G a ogni round con una semplice addizione EC
  affine, ripiegata nella batch inversion già presente (nuovo slot
  NEXT negli array Zj/prefix). La scalar mult è così ammortizzata su
  ~5120 chiavi invece di 128.

- Una sola inversione di campo per round invece di due: la
  normalizzazione del nuovo P0 condivide l'inversione di Montgomery
  del batch.

- Inversione modulare tramite la catena di addizione di libsecp256k1
  (255 quadrati + 15 moltiplicazioni) al posto del quadrato-e-moltiplica
  ingenuo (~256 + ~128). Rimosso il vecchio modinv_fermat e la costante
  FIELD_P_MINUS_2 non più usata.

- Rimosso l'array locale invZ[] (passaggio all'indietro fuso con la
  conversione affine + match), riducendo la memoria locale per-thread e
  migliorando l'occupancy.

Misurato nello stesso ambiente/scheda: 15.0M -> ~30M keys/sec.
Correttezza verificata end-to-end con privkey nota a offset 0, 50, 127,
128 (avanzamento del punto base), 200 e 5119 (40 avanzamenti
consecutivi): tutte trovate con la chiave privata corretta. Nessun
falso positivo su chiave pubblica valida casuale.

bruteforce/README.md

@@ -68,11 +68,12 @@ make gpu         # compila (default: sm_61 / Pascal — sovrascrivi con NVCC_ARC
 ./p2pk_bruteforce_gpu
 ```
 
-Su una Quadro P4000 (Pascal, 2016) si osservano ~15M keys/sec, contro i
-~300K-2M keys/sec della CPU — ma la moltiplicazione scalare su GPU non è
-ottimizzata quanto quella di libsecp256k1 (niente wNAF/tabelle precalcolate),
-quindi il margine di ulteriore miglioramento è ancora ampio su GPU più
-recenti.
+Su una Quadro P4000 (Pascal, 2016) si osservano ~30M keys/sec, contro i
+~300K-2M keys/sec della CPU. La moltiplicazione scalare (costosa) viene
+eseguita una sola volta per kernel launch e poi il punto base viene fatto
+avanzare con semplici addizioni EC ripiegate nella batch inversion, quindi il
+grosso del tempo è ora nell'aritmetica di campo; su GPU più recenti il
+margine di miglioramento è ancora ampio.
 
 > **Nota (WSL2)**: il driver NVIDIA arriva dal sistema Windows host (basta
 > che `nvidia-smi` funzioni già) — dentro WSL serve installare solo il CUDA