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/entities/player.cpp

@@ -11,7 +11,6 @@
 #include "core/resources/resource_cache.hpp"
 #include "external/fkyaml_node.hpp"
 #include "game/entities/event_bus.hpp"
-#include "game/map/map.hpp"
 #include "utils/defaults.hpp"
 
 namespace {
@@ -47,9 +46,10 @@ void Player::loadFrom(const std::string& yaml_path) {
     collision_y_offset = (sprite_h - base_size) - collision_padding;
 }
 
-Player::Player(const std::string& anim_key, float x, float y, const Controls& controls)
+Player::Player(const std::string& anim_key, float x, float y, const Controls& controls, const Map::Info& map_info)
     : AnimatedSprite(Resource::Cache::get().getAnimationData(anim_key)),
-      controls_(controls) {
+      controls_(controls),
+      map_(map_info) {
     setPos(x, y);
     setCurrentAnimation("stand");
 }
@@ -117,9 +117,9 @@ void Player::update(float delta_time) {
     setPos(OLD_X, OLD_Y);
 
     setPosX(NEW_X);
-    if (Map::collides(baseBox())) { setPosX(OLD_X); }
+    if (map_.collides(baseBox())) { setPosX(OLD_X); }
     setPosY(NEW_Y);
-    if (Map::collides(baseBox())) { setPosY(OLD_Y); }
+    if (map_.collides(baseBox())) { setPosY(OLD_Y); }
 
     clampToPlayfield();
 
@@ -157,28 +157,28 @@ auto Player::animationName(bool moving) const -> const char* {
 }
 
 auto Player::getCurrentTile() const -> std::pair<int, int> {
-    // El grid del tilemap és de `Map::tile_size` píxels i està 16-alineat
+    // El grid del tilemap és de `tile_size` píxels i està 16-alineat
     // respecte a l'origen del tilemap (pot ser negatiu per overscan). El
     // centre de la caixa de col·lisió ens dóna el tile on "està" el Player.
     const auto BOX = baseBox();
     const float CX = BOX.x + (BOX.w * 0.5F);
     const float CY = BOX.y + (BOX.h * 0.5F);
     const int COL = static_cast<int>(std::floor(
-        (CX - static_cast<float>(Map::tilemap_origin_x)) / static_cast<float>(Map::tile_size)));
+        (CX - static_cast<float>(map_.tilemap_origin_x)) / static_cast<float>(map_.tile_size)));
     const int ROW = static_cast<int>(std::floor(
-        (CY - static_cast<float>(Map::tilemap_origin_y)) / static_cast<float>(Map::tile_size)));
+        (CY - static_cast<float>(map_.tilemap_origin_y)) / static_cast<float>(map_.tile_size)));
     return {COL, ROW};
 }
 
 void Player::clampToPlayfield() {
     // Límits de la zona jugable: la caixa de col·lisió no pot eixir del
     // playfield (muros). El cap del sprite sí pot sobresortir per damunt.
-    const auto MIN_X = static_cast<float>(Map::playfield_x - collision_x_offset);
+    const auto MIN_X = static_cast<float>(map_.playfield_x - collision_x_offset);
     const auto MAX_X = static_cast<float>(
-        Map::playfield_x + Map::playfield_w - collision_x_offset - collision_size);
-    const auto MIN_Y = static_cast<float>(Map::playfield_y - collision_y_offset);
+        map_.playfield_x + map_.playfield_w - collision_x_offset - collision_size);
+    const auto MIN_Y = static_cast<float>(map_.playfield_y - collision_y_offset);
     const auto MAX_Y = static_cast<float>(
-        Map::playfield_y + Map::playfield_h - collision_y_offset - collision_size);
+        map_.playfield_y + map_.playfield_h - collision_y_offset - collision_size);
     setPosX(std::clamp(getPosX(), MIN_X, MAX_X));
     setPosY(std::clamp(getPosY(), MIN_Y, MAX_Y));
 }
@@ -214,24 +214,24 @@ void Player::snapToLane(
         const float STEP = std::min(std::abs(DELTA), SPEED_PX_PER_S * delta_time);
         const float SAVED = (this->*get_pos)();
         (this->*set_pos)(SAVED + std::copysign(STEP, DELTA));
-        if (Map::collides(baseBox())) { (this->*set_pos)(SAVED); }
+        if (map_.collides(baseBox())) { (this->*set_pos)(SAVED); }
     }
 }
 
 void Player::snapToHorizontalLane(float delta_time) {
     snapToLane(delta_time,
-        static_cast<float>(Map::playfield_y - collision_y_offset),
-        static_cast<float>(Map::pitch_y),
-        Map::grid_rows,
+        static_cast<float>(map_.playfield_y - collision_y_offset),
+        static_cast<float>(map_.pitch_y),
+        map_.grid_rows,
         &Player::getPosY,
         &Player::setPosY);
 }
 
 void Player::snapToVerticalLane(float delta_time) {
     snapToLane(delta_time,
-        static_cast<float>(Map::playfield_x - collision_x_offset),
-        static_cast<float>(Map::pitch_x),
-        Map::grid_cols,
+        static_cast<float>(map_.playfield_x - collision_x_offset),
+        static_cast<float>(map_.pitch_x),
+        map_.grid_cols,
         &Player::getPosX,
         &Player::setPosX);
 }