Fix five multiplayer sync bugs, add automated two-instance test

Adds test/multiPlayerTest.tscn plus a driver that runs the kitchen flow
across two game instances: grab/drop, dirt station, sink washing, hob
cooking, counter combining and plating. Runs headless (run_mp_test.ps1),
in two visible windows (run_mp_test_windowed.ps1), or by hand with
keyboard controls (play_mp_test.ps1). 108 checks, exits non-zero on
failure.

After every step both peers snapshot every item's position and rendered
state and the server diffs them. Targeted assertions only look at the
thing a step touched, which misses desyncs elsewhere - that audit is
what caught the last bug below.

Bugs found and fixed:

- net_pickable: apply_held_state() only wrote `enabled` in its
  non-authority branch, so once a client grabbed an item every other
  peer set enabled=false and regaining authority never restored it. The
  server could then never pick that item up again, and a station would
  "snap" it (emitting has_picked_up, so a plate still got marked dirty)
  while pick_up() bailed out on the disabled item - leaving the zone
  holding an item with no grab driver.

- network_manager: station gating only happened in the spawn path, so
  stations baked into a scene file kept running their snap zones on
  clients and grabbed items straight out of the local hand. Added
  gate_existing_stations().

- network_manager: despawn_item() only freed the server's copy. Items
  baked into a scene aren't tracked by the MultiplayerSpawner, so
  consuming one left a ghost on every client, which then blocked the
  station it sat in and got grabbed instead of its replacement.

- network_manager: the snap-into-station decision read the server's own
  copy of the item position, but the reliable release RPC routinely
  overtakes the synchronizer's unordered position updates - so it acted
  on a stale position and teleported items back into the station they
  had just been carried away from. The releasing peer now sends its
  final transform and the server adopts it first.

- container: contained_ids.append()/erase() mutate the array in place,
  which never fires the setter that rebuilds the plate's visuals. The
  peer that put food on a plate was the only peer that never redrew it;
  remote peers looked right because the synchronizer assigns there.

Also null-guards XRServer.get_tracker() in the vendored xr-tools hand
grab point, which threw on every successful grab without an XR runtime,
and adds multiplayer_world.populate_from_layout so debug scenes can bake
their own content instead of spawning the whole kitchen.

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

Net/net_pickable.gd

@@ -20,6 +20,10 @@ var _pickable: XRToolsPickable
 # apply_held_state() last forced it to while non-authority.
 var _original_freeze_mode: int
 
+# Same idea for the pickable's authored `enabled` flag, which the non-authority
+# branch of apply_held_state() clears while someone else is holding the item.
+var _original_enabled: bool
+
 
 func _ready() -> void:
 	_pickable = get_parent() as XRToolsPickable
@@ -27,6 +31,7 @@ func _ready() -> void:
 		push_error("NetPickable must be a child of an XRToolsPickable")
 		return
 	_original_freeze_mode = _pickable.freeze_mode
+	_original_enabled = _pickable.enabled
 	_pickable.picked_up.connect(_on_picked_up)
 	_pickable.dropped.connect(_on_dropped)
 	# Deferred: the pickable root captures its own original_collision_mask/
@@ -72,6 +77,22 @@ func apply_held_state() -> void:
 				)
 			_pickable.freeze_mode = _original_freeze_mode
 			_pickable.collision_mask = _pickable.original_collision_mask
+		# Unlike freeze/collision (which XRToolsPickable manages itself while
+		# held), `enabled` is only ever written by the non-authority branch
+		# below, so it must be restored here or it stays false forever: once a
+		# client grabbed this item, every other peer set enabled=false, and
+		# regaining authority left it that way. On the server that silently
+		# broke everything downstream — hands couldn't pick the item up again,
+		# and a station snap zone would "snap" it (emitting has_picked_up, so
+		# e.g. a plate still got marked dirty) while pick_up() bailed out on
+		# the disabled item, leaving the zone holding an item with no grab
+		# driver that then fell out of the station.
+		if _pickable.enabled != _original_enabled:
+			if NetworkManager.is_online():
+				print("%s: reclaiming ownership, restoring enabled %s->%s" % [
+					_pickable.name, _pickable.enabled, _original_enabled
+				])
+			_pickable.enabled = _original_enabled
 		return
 	# A net_held_by/position sync update can race ahead of the
 	# authority-handoff RPC that's about to confirm a grab we just made
@@ -132,8 +153,11 @@ func _on_dropped(_p) -> void:
 		print("%s dropped, reporting release to server (lin=%s ang=%s)" % [
 			_pickable.name, _pickable.linear_velocity, _pickable.angular_velocity
 		])
+	# Send our own final transform too: we were the authority until now, and the
+	# server's copy may not have received our last position sync yet.
 	NetworkManager.release_item_authority_from(
-		_pickable.get_path(), _pickable.linear_velocity, _pickable.angular_velocity
+		_pickable.get_path(), _pickable.linear_velocity, _pickable.angular_velocity,
+		_pickable.global_transform
 	)