fix(rules): name a repeated word in the move preview instead of scoring it

Composing an already-played word read as a perfectly legal move: the tiles
drew as legal, the caption showed "БРА = 6" and the ✅ was enabled, and
only the server refused the play with the bare "illegal move" toast.

The on-device evaluator already applied the rule, but it reported the
refusal as a plain illegal play, so nothing distinguished a repeated word
from a misspelling and the caption fell back to the turn label. It now
names the word it rejected, and the game screen reads
"БРА: уже использовано" above the scores while the tiles stay marked
invalid — the composition is wrong, but for a reason the player cannot
read off the board, since the word itself is in the dictionary. The
verdict is reached on the device before the play is ever offered to the
server, in an online game exactly as in an offline one; the offline
source reports the same reason through the same field.

Only the main word is ever refused: a cross-word the game has already
used still stands (it is incidental to laying the main word) and merely
scores nothing, so the rule cannot falsely block a play in a game with
several words per turn.

The scoring of such a play is now pinned to the point on both sides: the
engine test and the client test evaluate the same position — РОТ laid
across a standing КО, completing an already-played КОТ — and assert the
same totals (10 unrestricted, 5 with the rule), so a divergence between
the two engines breaks one of them. The client test also replays the
exact test-contour position this was reported from.

backend/internal/engine/norepeat_test.go

@@ -109,10 +109,7 @@ func TestNoRepeatDropsTheScoreOfAReplayedCrossWord(t *testing.T) {
 		t.Helper()
 		g, idx := newEruditNoRepeat(t, noRepeat)
 		playKotAtCentre(t, g, idx)
-		scrabble.Apply(g.board, scrabble.Move{Tiles: []scrabble.Placement{
-			{Row: 10, Col: 5, Letter: idx("к")},
-			{Row: 11, Col: 5, Letter: idx("о")},
-		}})
+		applyScaffold(t, g, idx)
 		g.hands[g.toMove] = []byte{idx("р"), idx("о"), idx("т")}
 		rec, err := g.EvaluatePlay([]TileRecord{
 			{Row: 12, Col: 3, Letter: "р"},
@@ -126,12 +123,19 @@ func TestNoRepeatDropsTheScoreOfAReplayedCrossWord(t *testing.T) {
 	}
 
 	unrestricted, restricted := evaluate(t, false), evaluate(t, true)
-	if restricted.Score >= unrestricted.Score {
-		t.Errorf("score with the rule = %d, want less than %d without it", restricted.Score, unrestricted.Score)
+	// Exact totals, not merely "less": the client port scores this very position in
+	// ui/src/lib/dict/eval.norepeat.test.ts and is pinned to the same two numbers, so a scoring
+	// divergence between the two engines breaks one of the two tests.
+	if unrestricted.Score != 10 {
+		t.Errorf("score without the rule = %d, want 10 (РОТ plus the КОТ cross-word)", unrestricted.Score)
+	}
+	if restricted.Score != 5 {
+		t.Errorf("score with the rule = %d, want 5 (РОТ alone; the repeated cross-word earns nothing)", restricted.Score)
 	}
 	// The word is still formed and still reported — it simply earns nothing.
-	if len(restricted.Words) != len(unrestricted.Words) {
-		t.Errorf("words with the rule = %v, want the same words as without it (%v)", restricted.Words, unrestricted.Words)
+	want := []string{"рот", "кот"}
+	if len(restricted.Words) != len(want) || restricted.Words[0] != want[0] || restricted.Words[1] != want[1] {
+		t.Errorf("words with the rule = %v, want %v", restricted.Words, want)
 	}
 }
 
@@ -173,3 +177,12 @@ func TestNoRepeatOffLeavesTheGameUnchanged(t *testing.T) {
 		t.Errorf("generated %d moves, want the solver's %d untouched", got, want)
 	}
 }
+
+// applyScaffold stands КО down column 5 above row 12, so a play across row 12 completes КОТ.
+func applyScaffold(t *testing.T, g *Game, idx func(string) byte) {
+	t.Helper()
+	scrabble.Apply(g.board, scrabble.Move{Tiles: []scrabble.Placement{
+		{Row: 10, Col: 5, Letter: idx("к")},
+		{Row: 11, Col: 5, Letter: idx("о")},
+	}})
+}