Fase 9a: extraer CollisionSystem de GameScene a modulo aparte

GameScene::detectar_col*_* (3 funciones de deteccion de gameplay,
~170 LOC) salen a Systems::Collision en
source/game/systems/collision_system.{hpp,cpp}.

API:
- struct Systems::Collision::Context: agrupa todo lo que las
  detecciones leen/modifican (ships, enemies, bullets, hit_timer,
  score, lives, debris, floating_score, match_config) y un callback
  on_player_hit para delegar la muerte del jugador.
- Funciones libres: detectBulletEnemy, detectShipEnemy,
  detectBulletPlayer y detectAll.

GameScene::update construye el Context y llama detectAll. La
funcion GameScene::tocado se inyecta via lambda. El cuerpo de update
queda mas legible y separa fisica de gameplay (lo decide el solver)
de fisica rigida (lo decide PhysicsWorld).

GameScene.cpp: 1429 -> 1274 LOC. Smoke test xvfb OK.

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

source/game/systems/collision_system.hpp

@@ -0,0 +1,63 @@
+// collision_system.hpp - Detección de colisiones de gameplay
+// © 2025 Orni Attack
+//
+// Detecta colisiones bullet↔enemy, ship↔enemy y bullet↔player y aplica los
+// efectos directos sobre las entidades (destruir enemy, desactivar bullet,
+// crear debris/floating-score, ajustar score y lives). Las consecuencias de
+// gameplay que requieren transición de estado (muerte del jugador, game over)
+// se delegan a un callback `on_player_hit`.
+//
+// Esto es física de gameplay, NO física rígida — el PhysicsWorld ya resolvió
+// los impulsos físicos antes. Aquí solo decidimos quién muere/destruye a quién.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <functional>
+
+#include "core/defaults.hpp"
+#include "core/system/game_config.hpp"
+#include "game/effects/debris_manager.hpp"
+#include "game/effects/floating_score_manager.hpp"
+#include "game/entities/bullet.hpp"
+#include "game/entities/enemy.hpp"
+#include "game/entities/ship.hpp"
+
+namespace Systems::Collision {
+
+// Todo lo que las detecciones necesitan leer/modificar. Vive en GameScene;
+// se le pasa por referencia (no copia, no ownership).
+struct Context {
+        std::array<Ship, 2>& ships;
+        std::array<Enemy, Defaults::Entities::MAX_ORNIS>& enemies;
+        std::array<Bullet, Defaults::Entities::MAX_BALES * 2>& bullets;
+        std::array<float, 2>& hit_timer_per_player;
+        std::array<int, 2>& score_per_player;
+        std::array<int, 2>& lives_per_player;
+        Effects::DebrisManager& debris_manager;
+        Effects::FloatingScoreManager& floating_score_manager;
+        const GameConfig::MatchConfig& match_config;
+        // Trigger de muerte del jugador (GameScene::tocado).
+        std::function<void(uint8_t /*player_id*/)> on_player_hit;
+};
+
+// Detecta colisiones bullet → enemy. Si hit:
+//   - destruye el enemy (radius=0 en physics body)
+//   - crea debris + floating score
+//   - desactiva la bullet
+//   - suma puntos al shooter
+void detectBulletEnemy(Context& ctx);
+
+// Detecta colisiones ship → enemy. Si hit, llama on_player_hit(player_id).
+void detectShipEnemy(Context& ctx);
+
+// Detecta colisiones bullet → player (friendly fire / self-hit).
+// Self-hit: el shooter pierde 1 vida. Teammate-hit: la víctima pierde 1, el
+// atacante gana 1. En ambos casos, llama on_player_hit y desactiva bullet.
+void detectBulletPlayer(Context& ctx);
+
+// Las tres en orden lógico del frame.
+void detectAll(Context& ctx);
+
+}  // namespace Systems::Collision