Bound individual vessel speed; stop Fleet.stop() accumulating it (#72)

Rotating the fleet and spamming a direction let vessels fall out of sync
and fly at wildly high speeds. The pivot cooldown added earlier throttled
how often the exploit could be triggered; it never touched the cause.

Fleet.stop() did `ship.velocity = ship.velocity + ship.fleet_velocity`,
compensating for the fact that Ship.velocity read zero during cruise. The
next steer refilled fleet_velocity, so every press-release cycle added a
whole cruise velocity to the ship's own, decaying only at `acceleration` in
between. Tapping faster than that bled it off stacked them without limit,
and ships desynced because each bled off at a rate set by its own distance
to its slot. Measured before this change: spamming a direction while
pivoting flew the fleet 32737 units in 3s against 784 for simply holding
the stick, with a vessel reaching 48x its own top speed.

The compensation existed because `velocity` was not the ship's real motion:
Ship snapped to its slot every tick and zeroed it, so the truth lived in a
second field and anything wanting it had to add the two together. Fixed at
that root rather than by clamping the symptom:

- fleet_velocity is now fed FORWARD into the steering instead of carried
  alongside it. The ship aims to travel at its slot's velocity plus a
  correction closing the gap, so holding formation costs no error and
  `velocity` is always true world motion.
- The snap only applies when the slot is standing still, which is the one
  case where converging asymptotically would leave a residue. While the
  slot moves the ship steers continuously - a snap there was the teleport
  that made `velocity` lie in the first place.
- A hard bound on the INTEGRATED result every tick, not merely on the
  request, so no sequence of commands can leave a vessel over its own top
  speed.
- Fleet.stop() injects nothing; it reports that the slot has halted.

tests/test_fleet_speed_bounded.gd covers it, and fails against the previous
code with the numbers above: no vessel exceeds its own top speed however
hard the direction is spammed, spamming cannot cover more ground than
holding the stick, both hold while the formation is pivoting, and the fleet
stays together.

test_space_time_distorder.gd now clears the asteroid and enemy groups at
setup, the same clean-slate idiom test_ship_lab.gd uses. Silencing the
spawners was never enough - what Main.tscn had already placed kept moving,
and losing the distorder vessel to a rock resets the multiplier correctly,
which the test then reported three stages later as a failed scene swap. It
also checks it still crews a distorder vessel before relying on that.

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

Ship.gd

@@ -13,7 +13,15 @@ const VESSEL_DEFINITIONS = preload("res://VesselDefinitions.gd")
 var definition: Resource
 var glow_color: Color = Color(0.25, 0.85, 1.0)
 var core_color: Color = Color.WHITE
+# The ship's TRUE world velocity - what `position` is actually integrated
+# from, and the single source of truth for how fast this vessel is moving.
+# Nothing else may contribute motion; see the note in _physics_process.
 var velocity: Vector2 = Vector2.ZERO
+# The velocity of this ship's formation SLOT (the fleet anchor's own travel).
+# Fed forward into the steering below rather than added on top of it: matching
+# the slot's speed is most of the job of holding formation, so supplying it
+# directly leaves `velocity` free to be a small correction and lets the ship
+# sit in its slot with no steady-state lag and no teleporting.
 var fleet_velocity: Vector2 = Vector2.ZERO
 var move_target: Vector2
 
@@ -109,22 +117,47 @@ func _physics_process(delta: float) -> void:
 	# "snaps onto its slot" formation tightness at any boost level that
 	# 1.0x already has.
 	var boost: float = GameState.fleet_speed_multiplier
+	var effective_acceleration: float = acceleration * boost
 	var to_target: Vector2 = move_target - position
 	var distance: float = to_target.length()
-	if distance <= arrive_radius * boost:
+
+	# Snap only when the slot is STANDING STILL. A stationary target is the
+	# one case where converging asymptotically would leave a permanent
+	# sub-pixel residue, and settling exactly is what "the fleet has arrived"
+	# means everywhere else in the game. While the slot is moving the ship
+	# steers continuously instead - a snap there would be a teleport, which
+	# is what used to make `velocity` read zero for a ship that was in fact
+	# travelling at cruise speed, and that lie is what the whole
+	# stop()/fleet_velocity bookkeeping tangle existed to paper over.
+	if fleet_velocity == Vector2.ZERO and distance <= arrive_radius * boost:
 		position = move_target
 		velocity = Vector2.ZERO
 	else:
-		var effective_acceleration: float = acceleration * boost
-		var braking_speed: float = sqrt(2.0 * effective_acceleration * distance)
-		var desired_speed: float = min(max_speed * boost, braking_speed)
-		var desired_velocity: Vector2 = to_target.normalized() * desired_speed
+		# Feed-forward plus correction. The ship aims to travel at its slot's
+		# velocity, plus whatever extra closes the gap to the slot - so
+		# holding formation costs no error, and `velocity` stays the ship's
+		# real motion rather than a residual that has to be added to
+		# something else to mean anything.
+		var correction: Vector2 = Vector2.ZERO
+		if distance > 0.001:
+			var braking_speed: float = sqrt(2.0 * effective_acceleration * distance)
+			correction = to_target.normalized() * min(max_speed * boost, braking_speed)
+		var desired_velocity: Vector2 = fleet_velocity + correction
+		# HARD BOUND on how fast any single vessel may travel, applied to the
+		# total and re-applied every tick. Feed-forward plus correction can
+		# ask for more than a vessel can actually fly, and without this the
+		# excess was free speed: a ship that had been handed a large velocity
+		# kept it, decaying only at `acceleration`. Clamping the REQUEST is
+		# not enough - the clamp has to sit on the integrated result, so no
+		# sequence of commands can leave a vessel travelling faster than its
+		# own top speed.
+		desired_velocity = desired_velocity.limit_length(max_speed * boost)
 		velocity = velocity.move_toward(desired_velocity, effective_acceleration * delta)
+		velocity = velocity.limit_length(max_speed * boost)
 		position += velocity * delta
 
-	var motion: Vector2 = velocity + fleet_velocity
-	if motion.length() > 8.0:
-		var target_angle: float = motion.angle() + PI / 2.0
+	if velocity.length() > 8.0:
+		var target_angle: float = velocity.angle() + PI / 2.0
 		rotation = lerp_angle(rotation, target_angle, rotation_speed * delta)