Fase 1d: rename del codi restant (effects, stage_system, locals)

Sweep final del naming a CamelCase/camelBack/lower_case:

Fitxers renombrats:
- effects/gestor_puntuacio_flotant.{hpp,cpp} -> floating_score_manager.{hpp,cpp}
- effects/puntuacio_flotant.hpp -> floating_score.hpp

Tipus (CamelCase):
- GestorPuntuacioFlotant -> FloatingScoreManager
- PuntuacioFlotant -> FloatingScore
- ConfigStage -> StageConfig
- ConfigSistemaStages -> StageSystemConfig
- NauTitol -> TitleShip
- EstatNau -> ShipState

Metodes publics (camelBack):
- obte_renderer -> getRenderer
- get_num_actius -> getActiveCount
- calcular_direccio_explosio -> computeExplosionDirection
- trobar_slot_lliure -> findFreeSlot
- explotar -> explode
- reiniciar -> reset
- es_valida -> isValid
- parsejar_fitxer -> parseFile
- carregar -> load
- crear_explosio -> createExplosion
- registrar_puntuacio -> registerScore
- construir_marcador -> buildScoreboard
- render_centered -> renderCentered

Camps struct publics (snake_case):
- actiu/actius -> active
- rotacio -> rotation, rotacio_visual -> visual_rotation
- acceleracio -> acceleration
- velocitat -> velocity
- escala/escala_inicial/objectiu/actual -> scale/initial_scale/...
- posicio/posicio_inicial/objectiu/actual -> position/initial_position/...
- fase_oscilacio -> oscillation_phase
- temps_estat -> state_time
- jugador_id -> player_id
- estat -> state
- brillantor -> brightness
- tipus -> type

Camps privats (sufix _):
- naus_ -> ships_, orni_ -> enemies_, bales_ -> bullets_
- gestor_puntuacio_ -> floating_score_manager_
- punt_mort_ -> death_position_, punt_spawn_ -> spawn_position_
- itocado_per_jugador_ -> hit_timer_per_player_
- vides_per_jugador_ -> lives_per_player_
- puntuacio_per_jugador_ -> score_per_player_
- estat_game_over_ -> game_over_state_
- continues_usados_ -> continues_used_

Constants:
- MARGE_ESQ/DRET/DALT/BAIX -> MARGIN_LEFT/RIGHT/TOP/BOTTOM

Variables locals i parametres comuns (snake_case):
- nau -> ship, enemic -> enemy, bala -> bullet
- forma -> shape, punt(s) -> point(s)
- jugador -> player, partida -> match
- temps -> time, missatge -> message

Diff: 59 fitxers, +1000/-1000 (simetric). Compila i enllaça.

Pendents per a futures fases (no bloquejants):
- Comentaris de capçalera en catala -> castella
- Variables locals/parametres minoritaris en catala
- Include guards (queden alguns #ifndef en lloc de #pragma once)

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

source/game/entities/enemy.cpp

@@ -1,4 +1,4 @@
-// enemic.cpp - Implementació d'enemics (ORNIs)
+// enemy.cpp - Implementació d'enemics (ORNIs)
 // © 1999 Visente i Sergi (versió Pascal)
 // © 2025 Port a C++20 amb SDL3
 
@@ -30,15 +30,15 @@ Enemy::Enemy(SDL_Renderer* renderer)
     // [NUEVO] Brightness específic per enemics
     brightness_ = Defaults::Brightness::ENEMIC;
 
-    // [NUEVO] Forma es carrega a init() segons el tipus
-    // Constructor no carrega forma per permetre tipus diferents
+    // [NUEVO] Forma es carrega a init() segons el type
+    // Constructor no carrega shape per permetre type diferents
 }
 
-void Enemy::init(EnemyType tipus, const Vec2* ship_pos) {
-    // Guardar tipus
-    type_ = tipus;
+void Enemy::init(EnemyType type, const Vec2* ship_pos) {
+    // Guardar type
+    type_ = type;
 
-    // Carregar forma segons el tipus
+    // Carregar shape segons el type
     const char* shape_file;
     float drotacio_min;
     float drotacio_max;
@@ -68,7 +68,7 @@ void Enemy::init(EnemyType tipus, const Vec2* ship_pos) {
 
         default:
             // Fallback segur: usar valors de PENTAGON
-            std::cerr << "[Enemy] Error: tipus desconegut ("
+            std::cerr << "[Enemy] Error: type desconegut ("
                       << static_cast<int>(type_) << "), utilitzant PENTAGON\n";
             shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
             velocity_ = Defaults::Enemies::Pentagon::VELOCITAT;
@@ -77,10 +77,10 @@ void Enemy::init(EnemyType tipus, const Vec2* ship_pos) {
             break;
     }
 
-    // Carregar forma
+    // Carregar shape
     shape_ = Graphics::ShapeLoader::load(shape_file);
-    if (!shape_ || !shape_->es_valida()) {
-        std::cerr << "[Enemy] Error: no s'ha pogut carregar " << shape_file << '\n';
+    if (!shape_ || !shape_->isValid()) {
+        std::cerr << "[Enemy] Error: no s'ha pogut load " << shape_file << '\n';
     }
 
     // [MODIFIED] Posició aleatòria amb comprovació de seguretat
@@ -131,12 +131,12 @@ void Enemy::init(EnemyType tipus, const Vec2* ship_pos) {
     // Angle aleatori de moviment
     angle_ = (std::rand() % 360) * Constants::PI / 180.0F;
 
-    // Rotació visual aleatòria (rad/s) dins del rang del tipus
+    // Rotació visual aleatòria (rad/s) dins del rang del type
     float drotacio_range = drotacio_max - drotacio_min;
     drotacio_ = drotacio_min + ((static_cast<float>(std::rand()) / RAND_MAX) * drotacio_range);
     rotacio_ = 0.0F;
 
-    // Inicialitzar estat d'animació
+    // Inicialitzar state d'animació
     animacio_ = EnemyAnimation();  // Reset to defaults
     animacio_.drotacio_base = drotacio_;
     animacio_.drotacio_objetivo = drotacio_;
@@ -182,15 +182,15 @@ void Enemy::update(float delta_time) {
 void Enemy::draw() const {
     if (esta_ && shape_) {
         // Calculate animated scale (includes invulnerability LERP)
-        float escala = calcular_escala_actual();
+        float scale = calcular_escala_actual();
 
         // brightness_ is already updated in update()
-        Rendering::render_shape(renderer_, shape_, center_, rotacio_, escala, 1.0F, brightness_);
+        Rendering::render_shape(renderer_, shape_, center_, rotacio_, scale, 1.0F, brightness_);
     }
 }
 
 void Enemy::mou(float delta_time) {
-    // Dispatcher: crida el comportament específic segons el tipus
+    // Dispatcher: crida el comportament específic segons el type
     switch (type_) {
         case EnemyType::PENTAGON:
             comportament_pentagon(delta_time);
@@ -472,7 +472,7 @@ void Enemy::actualitzar_rotacio_accelerada(float delta_time) {
 }
 
 float Enemy::calcular_escala_actual() const {
-    float escala = 1.0F;
+    float scale = 1.0F;
 
     // [NEW] Invulnerability LERP prioritza sobre palpitació
     if (timer_invulnerabilitat_ > 0.0F) {
@@ -486,13 +486,13 @@ float Enemy::calcular_escala_actual() const {
         // LERP scale from 0.0 to 1.0
         constexpr float START = Defaults::Enemies::Spawn::INVULNERABILITY_SCALE_START;
         constexpr float END = Defaults::Enemies::Spawn::INVULNERABILITY_SCALE_END;
-        escala = START + ((END - START) * smooth_t);
+        scale = START + ((END - START) * smooth_t);
     } else if (animacio_.palpitacio_activa) {
         // [EXISTING] Palpitació només quan no invulnerable
-        escala += animacio_.palpitacio_amplitud * std::sin(animacio_.palpitacio_fase);
+        scale += animacio_.palpitacio_amplitud * std::sin(animacio_.palpitacio_fase);
     }
 
-    return escala;
+    return scale;
 }
 
 // [NEW] Stage system API implementations