Skill tree, node-based building animation, bigger UI, and a 19x faster test suite

Gameplay and UI
- Research tree at the mothership gates which structures can be built and
  grants permanent fleet-capacity upgrades (GameState.SKILL_TREE,
  SkillTreeView). Node depth is derived from prerequisites, so the layout
  cannot drift out of step with the dependencies.
- Building info popup before committing to a build, with per-building cost
  and description.
- Ship crafter redrawn as a space factory with an assembly animation;
  mothership redrawn as a radial flagship; command centre as a plotting hub.
- Keyboard and mouse support (WASD, Q/E pivot, wheel zoom) for the web build.
- UI and font scaled up for phone use, via a custom Theme resource -
  gui/theme/default_font_size does not reach the default theme.
- Asteroids no longer spawn on top of the fleet's start position.
- Fleet formation origin derived from the layout's own offsets rather than
  the centroid, fixing the lurch when a lopsided formation started moving.
- Fleet.stop() brakes from the ship's TRUE motion (velocity +
  fleet_velocity). Ship zeroes its velocity when seated in its slot even
  while the anchor drags that slot forward, so braking from velocity alone
  stopped the fleet dead instead of coasting - and whether it did depended
  on the frame rate.

Animation architecture (issue #10)
- Buildings, projectiles and explosion VFX no longer animate by redrawing.
  Static geometry is rasterised once in _draw(); moving parts are NeonPiece
  children animated through node properties, which reuse the cached
  geometry. Every NeonDraw call expands into four antialiased polylines, so
  redrawing to move something re-tessellated all of it.

Test suite (issue #8): 1075s -> ~55s
- Runs from a copy on Termux's own filesystem. The project lives on
  Android's FUSE bridge, read through proot, where load("res://Main.tscn")
  alone cost 8.5s per test against ~2s natively - and nearly every test
  loads it.
- Runs 6 tests at a time, in a single proot-distro login, with output
  buffered per test and printed only on failure.
- --fixed-fps 60 pins delta instead of measuring the wall clock, so a test's
  result no longer depends on how busy the machine is. Without it,
  parallelism made two tests fail on 2 of 3 runs.
- A test passes only if it both exits 0 and prints ": PASS".
- 38 tests, green on three consecutive runs.

Bundles Carrois Gothic SC (Apache 2.0) with its licence text.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

ExplosionVFXBase.gd

@@ -22,14 +22,25 @@ func _ready() -> void:
 	for i in range(particle_count):
 		var angle: float = randf() * TAU
 		var speed: float = randf_range(min_speed, max_speed)
-		particles.append({
+		var p: Dictionary = {
 			"pos": Vector2.ZERO,
 			"vel": Vector2(cos(angle), sin(angle)) * speed,
 			"rot": randf() * TAU,
 			"rot_speed": randf_range(-6.0, 6.0),
 			"size": _random_particle_size(),
-		})
-	queue_redraw()
+		}
+		# Each particle is its own child CanvasItem, drawn once at its own
+		# fixed local shape (subclass decides the shape via
+		# _configure_particle). From here on the "animation" is just this
+		# child's position/rotation, exactly like Ship.gd/Asteroid.gd - no
+		# redraw, no re-tessellating four polylines per particle per frame.
+		var visual: ExplosionParticle = ExplosionParticle.new()
+		_configure_particle(visual, p)
+		if _particle_spins():
+			visual.rotation = p["rot"]
+		add_child(visual)
+		p["visual"] = visual
+		particles.append(p)
 
 
 func _process(delta: float) -> void:
@@ -37,22 +48,35 @@ func _process(delta: float) -> void:
 	if age >= lifetime:
 		queue_free()
 		return
+	# CanvasItem modulate is inherited down the tree, so setting it once
+	# here fades every particle's already-drawn shape for free - no need
+	# to recompute or re-draw a single one of them.
+	modulate.a = clamp(1.0 - (age / lifetime), 0.0, 1.0)
 	for p in particles:
 		p["pos"] += p["vel"] * delta
 		p["vel"] *= 0.9
 		p["rot"] += p["rot_speed"] * delta
-	queue_redraw()
-
-
-func _draw() -> void:
-	var alpha: float = clamp(1.0 - (age / lifetime), 0.0, 1.0)
-	for p in particles:
-		_draw_particle(p, alpha)
+		var visual: ExplosionParticle = p["visual"]
+		visual.position = p["pos"]
+		if _particle_spins():
+			visual.rotation = p["rot"]
 
 
 func _random_particle_size() -> float:
 	return randf_range(10.0, 20.0)
 
 
-func _draw_particle(_p: Dictionary, _alpha: float) -> void:
+# Called once per particle at spawn time. Subclasses set visual.draw_callable
+# to a closure that draws their own fixed local shape (a streak, a rock
+# chunk, ...) - it must not depend on `p` beyond values fixed at spawn (size,
+# initial velocity direction), since it never runs again.
+func _configure_particle(_visual: ExplosionParticle, _p: Dictionary) -> void:
 	pass
+
+
+# True for particle styles whose shape itself spins independently of its
+# direction of travel (tumbling debris). Energy streaks are drawn already
+# aligned to their (fixed) velocity direction, so giving them this unrelated
+# per-particle spin as well would visibly rotate them off their travel line.
+func _particle_spins() -> bool:
+	return false