longevity: unico arrotondamento al pari nel motore, esatto sul valore binario

Sposta arrotonda1 (round-half-to-even come Python) da test-fisici.ts a
curve.ts, esportata, cosi' entrambi i moduli condividono la stessa funzione
invece di due copie che sui pareggi potrebbero divergere.

Nel farlo, la versione precedente (moltiplica per 10, tolleranza 1e-9 sul
pareggio) si e' rivelata sbagliata su un caso reale: 86.35 non e' un
pareggio nel double che lo rappresenta (vale 86.34999999999999431...,
Python arrotonda a 86.3 senza ambiguita'), ma 86.35*10 arrotonda ESATTAMENTE
a 863.5 in virgola mobile, un pareggio fasullo creato dalla moltiplicazione.
La versione naive dava 86.4. Sostituita con un confronto esatto: scompone il
double in mantissa/esponente (bit IEEE 754) e confronta con aritmetica
razionale su BigInt, senza mai passare per una moltiplicazione che possa
introdurre o cancellare un pareggio.

Aggiunti in motore-curve.test.ts i casi che dimostrano il pareggio vero
(86.25 -> 86.2, 86.75 -> 86.8) e quello fasullo (86.35 -> 86.3, non 86.4:
blocca la regressione appena descritta).

tests/longevity/motore-curve.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import {
-  clamp, lerp, curvaCampana, curvaDecrescente, curvaCrescenteConPlateau,
+  clamp, lerp, arrotonda1, curvaCampana, curvaDecrescente, curvaCrescenteConPlateau,
   curvaDirettaX10, curvaDirettaX10Invertita, curvaGradini,
 } from '../../src/lib/longevity/motore/curve';
 
@@ -123,4 +123,27 @@ describe('curve del questionario, confrontate con l oracolo', () => {
     expect(lerp(-1, 0, 10, 0, 100)).toBe(0);   // t viene limitato a [0,1]
     expect(lerp(11, 0, 10, 0, 100)).toBe(100);
   });
+
+  // round(x, 1) di Python arrotonda al pari sui pareggi ESATTI (banker's
+  // rounding), non sempre in su. Senza questi casi un arrotondamento naive
+  // (Math.round(x*10)/10, che su 86.25 darebbe 86.3) sarebbe indistinguibile
+  // dal corretto in tutti gli altri test: qui il pareggio e' deliberato.
+  it('arrotonda1 arrotonda al pari sui pareggi esatti, come round() di Python', () => {
+    expect(arrotonda1(86.25)).toBe(86.2);  // 862 e' pari: resta 86.2, non sale a 86.3
+    expect(arrotonda1(86.75)).toBe(86.8);  // 867 e' dispari: sale a 86.8, non resta 86.7
+    expect(arrotonda1(86.24)).toBe(86.2);  // non un pareggio: arrotondamento normale, per basso
+    expect(arrotonda1(86.26)).toBe(86.3);  // non un pareggio: arrotondamento normale, per alto
+  });
+
+  // 86.35 NON e' un pareggio vero: il double che gli sta dietro vale
+  // 86.34999999999999431..., quindi Python arrotonda (senza ambiguita') a
+  // 86.3. Una prima versione di arrotonda1, che moltiplicava per 10 e
+  // testava una tolleranza, ci cadeva: 86.35 * 10 arrotonda ESATTAMENTE a
+  // 863.5 in virgola mobile (un pareggio creato dalla moltiplicazione, non
+  // presente nel valore originale) e restituiva 86.4. Questo test blocca
+  // proprio quella regressione.
+  it('arrotonda1 non inventa un pareggio dove il double non ce l ha (86.35 -> 86.3, non un pareggio)', () => {
+    expect(arrotonda1(86.35)).toBe(86.3);
+    expect(arrotonda1(-86.35)).toBe(-86.3);
+  });
 });