feat(rules): forbid repeating a word already on the board in Erudit

Russian "Эрудит" treats a word laid on the board as belonging to the
game: it cannot be laid again. Neither the solver, the backend nor the
offline JS port knew the rule, so a player (and the robot) could replay a
word freely. Official Scrabble places no such restriction, so both
Scrabble variants keep playing unrestricted.

The rule applies in two ways. A play whose main word is already on the
board is illegal, and is neither accepted nor generated. A play whose
perpendicular cross-word is already there stands — that word is
incidental to laying the main word — but scores nothing. The set of
played words is the game's own move journal, main words and cross-words
alike, compared decoded, so a word spelled with a blank is the same word.

It lives in the game layer, not the solver: only a game knows its
history, and the solver stays stateless and standard-rules. The backend
applies it at submit, at the move preview and over generated moves
(filtering and re-ranking them, so neither the robot nor the hint can
offer a play the engine would then refuse); the client port does the same
for the offline engine and for the on-device preview of an online game.

The rule is pinned per game (games.no_repeat_words, set from the variant
at creation) rather than keyed on the variant, because a game is replayed
from its journal on every open. Applied retroactively it would make an
already-played repeat illegal — closing that game as a draw — and would
rescore a play whose cross-word repeats an earlier word, shifting a live
game's totals. Games created before the rule keep playing without it. The
flag rides the wire as a trailing field because the client's preview must
score the way the server does, and offline games pin the same answer in
their own record.

backend/internal/engine/game.go

@@ -104,6 +104,11 @@ type Options struct {
 	// perpendicular cross-words are ignored. Callers always set this explicitly; the
 	// zero value (false) is the single-word rule.
 	MultipleWordsPerTurn bool
+	// NoRepeatWords enables the "Эрудит" rule under which a word already laid on the
+	// board cannot be laid again (see norepeat.go). It is pinned per game rather than
+	// derived from the variant, so a game started before the rule existed replays and
+	// scores unchanged; the zero value (false) is the unrestricted rule.
+	NoRepeatWords bool
 }
 
 // Game is the in-memory state of a single match and the pure rules engine over
@@ -127,6 +132,7 @@ type Game struct {
 	resigned      []bool       // per seat; a resigned seat is skipped and cannot win
 	dropoutTiles  DropoutTiles // disposition of a resigned seat's tiles
 	multipleWords bool         // false = single-word rule (perpendicular cross-words ignored)
+	noRepeatWords bool         // true = a word already on the board cannot be laid again
 	log           []MoveRecord
 }
 
@@ -164,6 +170,7 @@ func New(reg *Registry, opts Options) (*Game, error) {
 		resigned:      make([]bool, opts.Players),
 		dropoutTiles:  opts.DropoutTiles,
 		multipleWords: opts.MultipleWordsPerTurn,
+		noRepeatWords: opts.NoRepeatWords,
 	}
 	for i := range g.hands {
 		g.hands[i] = g.bag.Draw(rs.RackSize)
@@ -195,6 +202,10 @@ func (g *Game) Play(dir scrabble.Direction, tiles []scrabble.Placement) (MoveRec
 	if err != nil {
 		return MoveRecord{}, fmt.Errorf("%w: %v", ErrIllegalPlay, err)
 	}
+	move, err = g.noRepeat(move, g.playedWords())
+	if err != nil {
+		return MoveRecord{}, err
+	}
 
 	scrabble.Apply(g.board, move)
 	g.removeFromHand(player, placementTiles(tiles))
@@ -300,7 +311,7 @@ func (g *Game) ResignSeat(seat int) (MoveRecord, error) {
 // GenerateMoves returns every legal play for the current player's rack, ranked
 // by descending score. It is empty when the player has no legal play.
 func (g *Game) GenerateMoves() []scrabble.Move {
-	return g.solver.GenerateMovesOpts(g.board, g.rackOf(g.toMove), scrabble.Both, g.playOpts())
+	return g.noRepeatFilter(g.solver.GenerateMovesOpts(g.board, g.rackOf(g.toMove), scrabble.Both, g.playOpts()))
 }
 
 // Hint returns the highest-scoring legal play for the current player and true,