feat(loyalty): pay every game with EnakCoin

Games now spend the wallet's EnakCoin instead of the per-type tokens
(docs/prd-point-coin.md F8, K1, PC-403).

GamePlayProcessor.PlayGame charges the game's metadata.coin_cost, 1 when
it is not set; a cost that is not a whole number of at least 1 refuses the
game. In one transaction it picks the prize, takes the EnakCoin with a
GAME_SPEND row pointing at the new game_plays.id (which locks the wallet,
so a customer's plays at the same time queue up), records the play and
takes the prize from stock. The play owns its transaction, so the spin
service no longer wraps it, and the admin play endpoint is now atomic too.

The game, game prize and game play repositories go through DBFromContext
so they join that transaction. DecreaseStock now reports a prize that ran
out (ErrGamePrizeOutOfStock) instead of silently updating nothing; that,
or any other stock failure, cancels the whole play, where it used to be
only printed. The manual AddTokens rollback is gone. Not enough EnakCoin,
an inactive game or a prize that ran out answer 400 on /customer/spin
instead of 500.

game_plays.token_used is renamed coins_used (migration 000095). What a
play costs is no longer the caller's choice, so PlayGameRequest loses
token_used. Responses carry coins_used and coins_remaining; token_used and
tokens_remaining stay as deprecated copies until the apps move over, and
sort_by=token_used still sorts by coins_used.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/repository/game_prize_repository.go

@@ -3,12 +3,16 @@ package repository
 import (
 	"apskel-pos-be/internal/entities"
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/google/uuid"
 	"gorm.io/gorm"
 )
 
+// ErrGamePrizeOutOfStock means a prize had less stock than was taken from it.
+var ErrGamePrizeOutOfStock = errors.New("game prize is out of stock")
+
 type GamePrizeRepository struct {
 	db *gorm.DB
 }
@@ -18,12 +22,12 @@ func NewGamePrizeRepository(db *gorm.DB) *GamePrizeRepository {
 }
 
 func (r *GamePrizeRepository) Create(ctx context.Context, gamePrize *entities.GamePrize) error {
-	return r.db.WithContext(ctx).Create(gamePrize).Error
+	return DBFromContext(ctx, r.db).WithContext(ctx).Create(gamePrize).Error
 }
 
 func (r *GamePrizeRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.GamePrize, error) {
 	var gamePrize entities.GamePrize
-	err := r.db.WithContext(ctx).Preload("Game").Preload("FallbackPrize").Where("id = ?", id).First(&gamePrize).Error
+	err := DBFromContext(ctx, r.db).WithContext(ctx).Preload("Game").Preload("FallbackPrize").Where("id = ?", id).First(&gamePrize).Error
 	if err != nil {
 		return nil, err
 	}
@@ -32,7 +36,7 @@ func (r *GamePrizeRepository) GetByID(ctx context.Context, id uuid.UUID) (*entit
 
 func (r *GamePrizeRepository) GetByGameID(ctx context.Context, gameID uuid.UUID) ([]entities.GamePrize, error) {
 	var gamePrizes []entities.GamePrize
-	err := r.db.WithContext(ctx).Preload("Game").Preload("FallbackPrize").Where("game_id = ?", gameID).Find(&gamePrizes).Error
+	err := DBFromContext(ctx, r.db).WithContext(ctx).Preload("Game").Preload("FallbackPrize").Where("game_id = ?", gameID).Find(&gamePrizes).Error
 	if err != nil {
 		return nil, err
 	}
@@ -43,7 +47,7 @@ func (r *GamePrizeRepository) List(ctx context.Context, offset, limit int, searc
 	var gamePrizes []entities.GamePrize
 	var total int64
 
-	query := r.db.WithContext(ctx).Preload("Game").Preload("FallbackPrize")
+	query := DBFromContext(ctx, r.db).WithContext(ctx).Preload("Game").Preload("FallbackPrize")
 
 	if search != "" {
 		searchTerm := "%" + search + "%"
@@ -76,22 +80,31 @@ func (r *GamePrizeRepository) List(ctx context.Context, offset, limit int, searc
 }
 
 func (r *GamePrizeRepository) Update(ctx context.Context, gamePrize *entities.GamePrize) error {
-	return r.db.WithContext(ctx).Save(gamePrize).Error
+	return DBFromContext(ctx, r.db).WithContext(ctx).Save(gamePrize).Error
 }
 
 func (r *GamePrizeRepository) Delete(ctx context.Context, id uuid.UUID) error {
-	return r.db.WithContext(ctx).Delete(&entities.GamePrize{}, id).Error
+	return DBFromContext(ctx, r.db).WithContext(ctx).Delete(&entities.GamePrize{}, id).Error
 }
 
+// DecreaseStock takes amount from a prize's stock. When less than amount is left it
+// changes nothing and returns ErrGamePrizeOutOfStock.
 func (r *GamePrizeRepository) DecreaseStock(ctx context.Context, id uuid.UUID, amount int) error {
-	return r.db.WithContext(ctx).Model(&entities.GamePrize{}).
+	res := DBFromContext(ctx, r.db).WithContext(ctx).Model(&entities.GamePrize{}).
 		Where("id = ? AND stock >= ?", id, amount).
-		Update("stock", gorm.Expr("stock - ?", amount)).Error
+		Update("stock", gorm.Expr("stock - ?", amount))
+	if res.Error != nil {
+		return fmt.Errorf("failed to decrease prize stock: %w", res.Error)
+	}
+	if res.RowsAffected == 0 {
+		return ErrGamePrizeOutOfStock
+	}
+	return nil
 }
 
 func (r *GamePrizeRepository) GetAvailablePrizes(ctx context.Context, gameID uuid.UUID) ([]entities.GamePrize, error) {
 	var gamePrizes []entities.GamePrize
-	err := r.db.WithContext(ctx).Preload("Game").Preload("FallbackPrize").
+	err := DBFromContext(ctx, r.db).WithContext(ctx).Preload("Game").Preload("FallbackPrize").
 		Where("game_id = ? AND stock > 0", gameID).
 		Order("weight DESC").
 		Find(&gamePrizes).Error