fix: le HUD mettait à jour les compteurs des joueurs trop tôt pendant la résolution du tour

Cause : le serveur émet 'round-result' (déclenche l'animation de révélation
des cartes/gains sur le plateau Phaser, ~3.5s avant le tour suivant) et
'game-state' en phase 'resolve' (déjà avec les jauges/scores post-résolution
via getPlayersInfo) au même instant. Le HUD Vue (alimenté directement par
gameStore.players) sautait donc à ses nouvelles valeurs INSTANTANÉMENT, en
même temps que l'animation de résolution démarrait tout juste sur le
plateau — les compteurs changeaient avant/pendant que le joueur voie
l'animation qui justifie ce changement, au lieu d'être synchronisés avec
elle.

Fix : le store Pinia (client/src/stores/game.js) gèle désormais
players/currentTurn pendant toute la phase 'resolve' — les valeurs reçues
sont stockées dans un buffer interne (_pendingPlayers/_pendingCurrentTurn)
au lieu d'être appliquées immédiatement, et ne sont propagées à l'affichage
qu'au game-state suivant dont la phase n'est PLUS 'resolve' (typiquement
'selecting' du tour suivant, ou 'end'). Le reste de l'état (phase, main,
objets/bâtiments/événements) continue de se mettre à jour normalement et
immédiatement — seul l'affichage des jauges/scores est différé.

6 nouveaux tests unitaires (game.store.test.js) couvrant le gel/dégel du
buffer, la rediffusion de plusieurs game-state en phase 'resolve'
successifs, la transition directe vers 'end', et le nettoyage du buffer
par reset().

Nouveau test E2E (hud-resolution-timing.spec.js) confirmé discriminant :
échoue de façon reproductible (2/2 tentatives) sans le fix ("0 pts" attendu
pendant resolve, "5 pts" déjà affiché), passe systématiquement avec le fix
(stable sur 3 répétitions). Attente active de la phase 'resolve' via
expect.poll plutôt qu'un délai fixe, pour éviter la fenêtre d'observation
manquée sous charge variable.

60 tests unitaires client + 166 tests unitaires serveur + suite
game-flow.spec.js (4 tests, non liée à ce fix) toujours au vert.

client/test/unit/game.store.test.js

@@ -155,6 +155,73 @@ describe('stores/game (Pinia)', () => {
       expect(store.pendingEventPlayId).toBeNull()
       expect(store.hasPendingEventDraw).toBe(false)
     })
+
+    describe('gel du HUD pendant la phase "resolve"', () => {
+      it('ne met PAS à jour players/currentTurn immédiatement quand phase="resolve"', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 1, phase: 'selecting' })
+
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' })
+
+        // Les valeurs affichées restent celles d'AVANT la résolution
+        expect(store.players).toEqual([{ name: 'Alice', score: 0 }])
+        expect(store.phase).toBe('resolve') // la phase, elle, est bien mise à jour immédiatement
+      })
+
+      it('applique les valeurs gelées au prochain game-state qui sort de la phase "resolve"', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 1, phase: 'selecting' })
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' })
+
+        // Le tour suivant arrive (phase='selecting', currentTurn=2) : les
+        // valeurs gelées (score=5 du round-result) doivent s'appliquer ici,
+        // PAS les valeurs de ce nouveau game-state si elles diffèrent.
+        store.updateState({ players: [{ name: 'Alice', score: 999 }], currentTurn: 2, phase: 'selecting' })
+
+        expect(store.players).toEqual([{ name: 'Alice', score: 5 }])
+        expect(store.currentTurn).toBe(1)
+      })
+
+      it('applique directement les valeurs si phase="end" suit "resolve" (fin de partie)', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 12, phase: 'selecting' })
+        store.updateState({ players: [{ name: 'Alice', score: 42 }], currentTurn: 12, phase: 'resolve' })
+        store.updateState({ players: [{ name: 'Alice', score: 42 }], currentTurn: 13, phase: 'end' })
+
+        expect(store.players).toEqual([{ name: 'Alice', score: 42 }])
+        expect(store.phase).toBe('end')
+      })
+
+      it('n\'affecte pas les valeurs si la phase ne passe jamais par "resolve" (mise à jour directe classique)', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 3 }], currentTurn: 2, phase: 'waiting' })
+        expect(store.players).toEqual([{ name: 'Alice', score: 3 }])
+        expect(store.currentTurn).toBe(2)
+      })
+
+      it('un second game-state en phase "resolve" (rediffusion) écrase le buffer avec les valeurs les plus récentes', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 0 }], currentTurn: 1, phase: 'selecting' })
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' })
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 1, phase: 'resolve' }) // rediffusion identique
+
+        store.updateState({ players: [{ name: 'Alice', score: 999 }], currentTurn: 2, phase: 'selecting' })
+
+        expect(store.players).toEqual([{ name: 'Alice', score: 5 }])
+      })
+
+      it('reset() vide aussi le buffer interne (pas de fuite de valeurs gelées vers une nouvelle partie)', () => {
+        const store = useGameStore()
+        store.updateState({ players: [{ name: 'Alice', score: 5 }], currentTurn: 3, phase: 'resolve' })
+        store.reset()
+
+        // Après reset, un nouveau game-state 'selecting' doit s'appliquer
+        // directement, sans que le buffer de l'ancienne partie ne persiste.
+        store.updateState({ players: [{ name: 'Bob', score: 0 }], currentTurn: 1, phase: 'selecting' })
+        expect(store.players).toEqual([{ name: 'Bob', score: 0 }])
+        expect(store.currentTurn).toBe(1)
+      })
+    })
   })
 
   describe('selectCard / clearSelection', () => {