Fase 1e: cierre de naming sweep (#pragma once, locals, comentarios castellano)

Tres tareas de pulido para cerrar la Fase 1 por completo:

#pragma once uniforme:
- sdl_manager.hpp y game_scene.hpp pasan de #ifndef/#define guards
  a #pragma once. Los archivos externos (stb_vorbis.h, fkyaml_node.hpp)
  se mantienen intactos (codigo de terceros).

Variables locales y parametros restantes (catalan -> ingles):
- fitxer -> file, moviment -> movement, inici -> start
- comptador -> counter, escalada -> scaled
- missatges -> messages, llista -> list
- alçada -> height, amplada -> width, llargada -> length
- origen -> origin, distancia -> distance, valor -> value, desti -> target
- neteja -> clear, presenta -> present (SDLManager)
- total_enemics -> total_enemies, configurar -> configure, iniciar -> start

Comentarios catalan -> castellano:
- Cabeceras de fichero actualizadas con nombres nuevos
  (escena_joc.hpp -> game_scene.hpp, etc.)
- Palabras tecnicas: trasllacio->traslacion, col-lisio->colision,
  inicialitzacio->inicializacion, posicio->posicion, rotacio->rotacion,
  velocitat->velocidad, acceleracio->aceleracion, explosio->explosion,
  renderitzat->renderizado, calcul->calculo, transicio->transicion,
  comprovacio->comprobacion, substitucio->sustitucion,
  utilitzacio->utilizacion, opcio->opcion, configuracio->configuracion,
  funcio->funcion, distancia, animacio->animacion
- Determinantes y conectores: aquest->este, aquesta->esta,
  amb->con, sense->sin, pero->pero, mai->nunca, nomes->solo,
  tambe->tambien, sempre->siempre, ja->ya, mateix->mismo,
  vegada->vez, dintre->dentro, fora->fuera, dreta->derecha,
  esquerra->izquierda, sortir->salir, sortida->salida,
  petit->pequeno, gran->grande, nou->nuevo, vell->viejo,
  molt->mucho, els->los, les->las, totes les->todas las,
  d'->de, com->como, quan->cuando, mentre->mientras,
  despres->despues, abans->antes, durant->durante, fins->hasta,
  encara->aun, llavors->entonces, aixi->asi, perque->porque
- Sustantivos: classe->clase, metode->metodo, parametre->parametro,
  versio->version, entitat->entidad, joc->juego, nivell->nivel,
  enemic->enemigo, naus->naves, bales->balas, fitxer->archivo,
  pentagon->pentagono, pun- tuacio->puntuacion, flotant->flotante,
  titol->titulo, objectiu->objetivo, mostra->muestra, tipus->tipo

Strings literales preservados en valenciano segun decision del
usuario: el texto del HUD del juego (puntuaciones, mensajes en
pantalla, archivo de config) se mantiene en valenciano original.

70 fitxers tocats, +1117 / -1123. Compila i enllaca.

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

source/core/rendering/shape_renderer.cpp

@@ -1,5 +1,5 @@
-// shape_renderer.cpp - Implementació del renderitzat de formes
-// © 2025 Port a C++20 amb SDL3
+// shape_renderer.cpp - Implementació del renderizado de formes
+// © 2025 Port a C++20 con SDL3
 
 #include "core/rendering/shape_renderer.hpp"
 
@@ -10,65 +10,65 @@
 
 namespace Rendering {
 
-// Helper: aplicar rotació 3D a un point 2D (assumeix Z=0)
+// Helper: aplicar rotación 3D a un point 2D (assumeix Z=0)
 static Vec2 apply_3d_rotation(float x, float y, const Rotation3D& rot) {
-    float z = 0.0F;  // Tots els points 2D comencen a Z=0
+    float z = 0.0F;  // Todos los points 2D comencen a Z=0
 
-    // Pitch (rotació eix X): cabeceo arriba/baix
+    // Pitch (rotación eix X): cabeceo arriba/baix
     float cos_pitch = std::cos(rot.pitch);
     float sin_pitch = std::sin(rot.pitch);
     float y1 = (y * cos_pitch) - (z * sin_pitch);
     float z1 = (y * sin_pitch) + (z * cos_pitch);
 
-    // Yaw (rotació eix Y): guiñada esquerra/dreta
+    // Yaw (rotación eix Y): guiñada izquierda/derecha
     float cos_yaw = std::cos(rot.yaw);
     float sin_yaw = std::sin(rot.yaw);
     float x2 = (x * cos_yaw) + (z1 * sin_yaw);
     float z2 = (-x * sin_yaw) + (z1 * cos_yaw);
 
-    // Roll (rotació eix Z): alabeo lateral
+    // Roll (rotación eix Z): alabeo lateral
     float cos_roll = std::cos(rot.roll);
     float sin_roll = std::sin(rot.roll);
     float x3 = (x2 * cos_roll) - (y1 * sin_roll);
     float y3 = (x2 * sin_roll) + (y1 * cos_roll);
 
     // Proyecció perspectiva (Z-divide simple)
-    // Naus volen cap al point de fuga (320, 240) a "infinit" (Z → +∞)
-    // Z més gran = més lluny = més petit a pantalla
+    // Naves quieren hacia el point de fuga (320, 240) a "infinit" (Z → +∞)
+    // Z més grande = més lluny = més pequeño a pantalla
     constexpr float perspective_factor = 500.0F;
     float scale_factor = perspective_factor / (perspective_factor + z2);
 
     return {.x = x3 * scale_factor, .y = y3 * scale_factor};
 }
 
-// Helper: transformar un point amb rotació, scale i trasllació
+// Helper: transformar un point con rotación, scale i traslación
 static Vec2 transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale, const Rotation3D* rotation_3d) {
-    // 1. Centrar el point respecte al centre de la shape
+    // 1. Centrar el point respecte al centro de la shape
     float centered_x = point.x - shape_centre.x;
     float centered_y = point.y - shape_centre.y;
 
-    // 2. Aplicar rotació 3D (si es proporciona)
+    // 2. Aplicar rotación 3D (si es proporciona)
     if ((rotation_3d != nullptr) && rotation_3d->has_rotation()) {
         Vec2 rotated_3d = apply_3d_rotation(centered_x, centered_y, *rotation_3d);
         centered_x = rotated_3d.x;
         centered_y = rotated_3d.y;
     }
 
-    // 3. Aplicar scale al point (després de rotació 3D)
+    // 3. Aplicar scale al point (después de rotación 3D)
     float scaled_x = centered_x * scale;
     float scaled_y = centered_y * scale;
 
-    // 4. Aplicar rotació 2D (Z-axis, tradicional)
-    // IMPORTANT: En el sistema original, angle=0 apunta AMUNT (no dreta)
+    // 4. Aplicar rotación 2D (Z-axis, tradicional)
+    // IMPORTANT: En el sistema original, angle=0 apunta AMUNT (no derecha)
     // Per això usem (angle - PI/2) per compensar
-    // Però aquí angle ja ve en el sistema correcte del joc
+    // Pero aquí angle ya ve en el sistema correcte del juego
     float cos_a = std::cos(angle);
     float sin_a = std::sin(angle);
 
     float rotated_x = (scaled_x * cos_a) - (scaled_y * sin_a);
     float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);
 
-    // 5. Aplicar trasllació a posició mundial
+    // 5. Aplicar traslación a posición mundial
     return {.x = rotated_x + position.x, .y = rotated_y + position.y};
 }
 
@@ -80,7 +80,7 @@ void render_shape(SDL_Renderer* renderer,
     float progress,
     float brightness,
     const Rotation3D* rotation_3d) {
-    // Verificar que la shape és vàlida
+    // Verificar que la shape es vàlida
     if (!shape || !shape->isValid()) {
         return;
     }
@@ -90,10 +90,10 @@ void render_shape(SDL_Renderer* renderer,
         return;
     }
 
-    // Obtenir el centre de la shape per a transformacions
+    // Obtenir el centro de la shape para transformacions
     const Vec2& shape_centre = shape->getCenter();
 
-    // Iterar sobre totes les primitives
+    // Iterar sobre todas las primitives
     for (const auto& primitive : shape->get_primitives()) {
         if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
             // POLYLINE: connectar points consecutius