Remove the one-way ore API superseded by the transfer menu

The loose end from #24. withdraw_to_fleet, unload_into_building and
deliver_cargo were the old one-way moves behind "Load ore" and "Store
ore here"; every one of them is a special case of transfer_to_building /
transfer_to_fleet, and none had a caller left outside tests. The
cargo_delivered signal had no listeners at all.

Not just tidying: unload_into_building routed through
deposit_to_building, which does NOT special-case the mothership - it
writes b.stock, while building_holdings() returns `rocks` for a
mothership and ignores stock entirely. So unload_into_building(
mothership_id) would have parked ore in a field nothing reads, with no
error. Nothing called it that way, but it is a plausibly-named function
sitting there to be reached for later. transfer_to_building handles it.

CARGO_LOAD_BATCH stays - the transfer menu's batch buttons use it; only
its role as withdraw_to_fleet's default argument is gone.

The #24 note expected folding these in to be costly for
test_cargo_readout, which places no buildings. It is not: the transfer
primitives work off GameState records rather than spawned nodes, so a
single add_building() in setup is enough and it stays a display test.

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

GameState.gd

@@ -38,53 +38,70 @@ var rocks: int = 500
 # surface would otherwise be dropped the moment the player took off.
 var fleet_cargo: int = 0
 
-signal cargo_delivered(amount: int)
-
-
 func collect_cargo(amount: int = 1) -> void:
 	fleet_cargo += amount
 
 
-# One press of "load ore" at the mothership. A batch rather than the whole
-# bank: the hold is the part that can be lost, and emptying the bank in one
-# tap would also strand research, which still spends from it.
+# The batch size the transfer menu offers, next to "All". A batch rather
+# than only all-or-nothing: the hold is the part that can be lost, and
+# emptying the bank in one tap would strand research, which spends from it.
 const CARGO_LOAD_BATCH: int = 25
 
 
-func withdraw_to_fleet(amount: int = CARGO_LOAD_BATCH) -> int:
-	# Banked ore back into the hold, so the fleet can carry it to a building
-	# that is waiting on it (#17).
-	var taken: int = mini(amount, rocks)
-	if taken <= 0:
-		return 0
-	rocks -= taken
-	fleet_cargo += taken
-	return taken
+# --- moving ore by hand, in either direction (#24) --------------------------
+#
+# One pair of primitives the transfer menu drives, rather than the two
+# one-way special cases that used to live inside the skill and craft panels
+# ("load ore" at the mothership, "store ore here" at a crafter).
+#
+# The mothership is deliberately not a special case in the UI: it is simply
+# the building whose holdings ARE the bank. Depositing at one banks the ore,
+# withdrawing from one draws on the bank, and every other building keeps its
+# own stock (#16). That is what lets one menu serve every structure.
 
 
-func unload_into_building(id: int) -> int:
-	# Everything the fleet is carrying, into this building's stock. Returns
-	# how much moved so a caller can tell the player something happened.
-	if fleet_cargo <= 0:
+func building_holdings(id: int) -> int:
+	var b: Dictionary = find_building(id)
+	if b.is_empty():
 		return 0
-	var moved: int = fleet_cargo
-	if deposit_to_building(id, moved) <= 0:
+	if b.type == BUILDING_MOTHERSHIP:
+		return rocks
+	return int(b.get("stock", 0))
+
+
+func transfer_to_building(id: int, amount: int) -> int:
+	# Hold -> this building. Returns how much actually moved, which is capped
+	# by the hold: a caller asking for "all" passes a number too big on
+	# purpose and reads the result back.
+	var b: Dictionary = find_building(id)
+	if b.is_empty():
 		return 0
-	fleet_cargo = 0
+	var moved: int = mini(amount, fleet_cargo)
+	if moved <= 0:
+		return 0
+	fleet_cargo -= moved
+	if b.type == BUILDING_MOTHERSHIP:
+		rocks += moved
+	else:
+		b.stock = int(b.get("stock", 0)) + moved
 	return moved
 
 
-func deliver_cargo() -> int:
-	# Everything the fleet is carrying, banked at once. Returns how much moved
-	# so a caller can react to a delivery actually having happened rather than
-	# to merely being in range.
-	if fleet_cargo <= 0:
+func transfer_to_fleet(id: int, amount: int) -> int:
+	# This building -> hold. Capped by what the building actually holds, so
+	# there is no overdraft in either direction.
+	var b: Dictionary = find_building(id)
+	if b.is_empty():
 		return 0
-	var delivered: int = fleet_cargo
-	rocks += delivered
-	fleet_cargo = 0
-	cargo_delivered.emit(delivered)
-	return delivered
+	var moved: int = mini(amount, building_holdings(id))
+	if moved <= 0:
+		return 0
+	if b.type == BUILDING_MOTHERSHIP:
+		rocks -= moved
+	else:
+		b.stock = int(b.get("stock", 0)) - moved
+	fleet_cargo += moved
+	return moved
 
 const MOTHERSHIP_COST: int = 20
 const SHIP_CRAFTER_COST: int = 12