refactor(game): COUP-02 inject MapInfo snapshot into Player

Afegit `Map::Info` (POD trivialment copiable) que empaqueta playfield,
pitch, grid, tile_size, tilemap_origin + 2 punters a funció (collides,
inside_playfield). `Map::makeInfo()` el construeix a partir dels globals
del namespace.

`Player` ara rep `const Map::Info&` al ctor i en guarda una còpia plana
(`map_`), substituint totes les lectures de `Map::*` per `map_.*`. La
inclusió `#include "game/map/map.hpp"` puja al header per la dependència
de `Map::Info`; player.cpp deixa d'incloure'l (transitiu).

Només el Player es desacobla — momies, roques i `loadFromLevel`
continuen llegint `Map::*` directament, com diu la nota original del
audit (mentre hi hagi un Map global actiu, l'acoblament és acceptable).
Si quan s'acabi PATCH-01 algun consumidor extra chirría, COUP-02b en
una rama nova.

Smoke tests 13/13 OK; log Game start → Bye! sota xvfb-run idèntic al
baseline. clang-tidy i cppcheck nets sobre els fitxers modificats.

Refs: docs/audit-game.md (COUP-02).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

source/game/map/map.cpp

@@ -104,4 +104,22 @@ namespace Map {
         return box.x >= static_cast<float>(playfield_x) && box.y >= static_cast<float>(playfield_y) && box.x + box.w <= static_cast<float>(playfield_x + playfield_w) && box.y + box.h <= static_cast<float>(playfield_y + playfield_h);
     }
 
+    auto makeInfo() -> Info {
+        return {
+            .playfield_x = playfield_x,
+            .playfield_y = playfield_y,
+            .playfield_w = playfield_w,
+            .playfield_h = playfield_h,
+            .pitch_x = pitch_x,
+            .pitch_y = pitch_y,
+            .grid_cols = grid_cols,
+            .grid_rows = grid_rows,
+            .tile_size = tile_size,
+            .tilemap_origin_x = tilemap_origin_x,
+            .tilemap_origin_y = tilemap_origin_y,
+            .collides = &collides,
+            .inside_playfield = &insidePlayfield,
+        };
+    }
+
 }  // namespace Map

source/game/map/map.hpp

@@ -14,6 +14,14 @@
 // els membres viuen com a globals del namespace i els callers hi accedeixen
 // amb `Map::grid_cols`, `Map::collides(...)`, etc. El canvi respecte a
 // l'anterior `class Map { static ... };` és purament sintàctic.
+//
+// `MapInfo` (POD trivialment copiable) empaqueta la geometria + dos
+// punters a funció de col·lisió per injectar-la a entitats que han
+// d'evitar conèixer el namespace `Map::` directament. Construïda via
+// `Map::makeInfo()` després de `loadFrom`. Avui només l'usa el Player
+// (COUP-02 a docs/audit-game.md); momies, roques i `loadFromLevel`
+// continuen llegint `Map::*` directament — la nota original justifica
+// que mentre hi hagi un Map global actiu, l'acoblament és acceptable.
 namespace Map {
 
     // Geometria de la graella (carregada de pyramid.yaml > geometry).
@@ -73,4 +81,27 @@ namespace Map {
     // entitats dinàmiques per validar posicions candidates del seu step.
     [[nodiscard]] auto insidePlayfield(const SDL_FRect& box) -> bool;
 
+    // Snapshot plà de la geometria del mapa + punters a `collides` /
+    // `insidePlayfield`. Pensat per ser passat per valor (POD petit,
+    // trivialment copiable). Un cop construïda, llegeix els valors
+    // congelats — si `Map::loadFrom` es torna a cridar amb un mapa
+    // diferent, cal demanar un MapInfo nou.
+    struct Info {
+        int playfield_x{0};
+        int playfield_y{0};
+        int playfield_w{0};
+        int playfield_h{0};
+        int pitch_x{0};
+        int pitch_y{0};
+        int grid_cols{0};
+        int grid_rows{0};
+        int tile_size{0};
+        int tilemap_origin_x{0};
+        int tilemap_origin_y{0};
+        bool (*collides)(const SDL_FRect&){nullptr};
+        bool (*inside_playfield)(const SDL_FRect&){nullptr};
+    };
+
+    [[nodiscard]] auto makeInfo() -> Info;
+
 }  // namespace Map