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>

AsteroidField.gd

@@ -7,6 +7,10 @@ extends Node2D
 
 @export var check_interval: float = 1.0
 @export var spawn_radius_chunks: int = 2
+# No asteroid may be created within this distance of the fleet. At cruise
+# speed this is well over a second of warning, so anything that reaches the
+# fleet was visible on its way in.
+@export var safe_spawn_radius: float = 420.0
 @export var despawn_radius_chunks: int = 4
 @export var asteroids_per_chunk: int = 6
 @export var min_speed: float = 12.0
@@ -63,14 +67,31 @@ func _chebyshev_chunk_distance(a: Vector2i, b: Vector2i) -> int:
 	return max(abs(a.x - b.x), abs(a.y - b.y))
 
 
+func _safe_position(candidate: Vector2, centre: Vector2) -> Vector2:
+	# Nothing may materialise on top of the fleet. Chunks are populated around
+	# wherever the fleet happens to be - including the chunk it is standing in
+	# - so without this an asteroid could appear directly on a ship and
+	# destroy it with no chance to react. That is worst on the frame a scene
+	# loads: arriving back from a planet could cost a ship instantly.
+	if candidate.distance_to(centre) >= safe_spawn_radius:
+		return candidate
+	# Push it out to the edge of the bubble rather than dropping it, so the
+	# field keeps its density near the fleet instead of thinning out.
+	var away: Vector2 = candidate - centre
+	if away.length() < 0.001:
+		away = Vector2.RIGHT.rotated(randf() * TAU)
+	return centre + away.normalized() * safe_spawn_radius
+
+
 func _spawn_chunk_asteroids(chunk: Vector2i) -> void:
 	var origin: Vector2 = WorldGen.chunk_origin(chunk)
 	var spawned: Array = []
+	var fleet_centre: Vector2 = fleet.get_centroid()
 
 	for i in range(asteroids_per_chunk):
 		var local_pos: Vector2 = Vector2(randf() * WorldGen.CHUNK_SIZE, randf() * WorldGen.CHUNK_SIZE)
 		var asteroid: Node2D = asteroid_scene.instantiate()
-		asteroid.position = origin + local_pos
+		asteroid.position = _safe_position(origin + local_pos, fleet_centre)
 		var angle: float = randf() * TAU
 		var speed: float = randf_range(min_speed, max_speed)
 		asteroid.velocity = Vector2(cos(angle), sin(angle)) * speed