Phase 7: netfox + godot-jolt stack upgrade

Stack installed:
- netfox v1.35.3 (core + extras + noray + internals)
- godot-jolt v0.16.0-stable

Architecture:
- Server: ENet transport (works headless, no netfox deps)
- Client/Editor: netfox rollback (RollbackSynchronizer, TickInterpolator)

New/modified:
- docs/migration-netfox-plan.md — migration architecture
- scripts/network/network_manager.gd — netfox-aware ENet fallback
- scripts/network/player.gd — clean base player
- client/characters/player_netfox.gd — rollback player w/ WeaponManager
- client/characters/input/player_net_input.gd — BaseNetInput subclass
- client/characters/character/fps_character_controller.gd — netfox input feed
- client/weapons/ — weapon data, registry, TacticalWeaponHitscan, WeaponManager
- client/scripts/round_replicator.gd — client-side round state bridge
- server/scripts/round_manager.gd — improved state machine
- server/scripts/plugin_api/plugin_manager.gd — refined plugin system
- config: enemy_tag, ally_tag for meatball targeting

Removed: old C++ SimulationServer GDExtension (replaced by netfox rollback)

addons/netfox.extras/physics/physics_driver.gd

@@ -0,0 +1,86 @@
+extends Node
+
+class_name PhysicsDriver
+
+# Physics driver based on netfox ticks
+# Step physics in time with netfox and participates in rollback
+
+var physics_space: RID
+var snapshots: Dictionary = {}
+
+# Number of physics steps to take per network tick
+@export var physics_factor: int = 2
+# Snapshot and Rollback entire physics space.
+@export var rollback_physics_space: bool = true
+
+func _enter_tree():
+	#regular ticks
+	NetworkTime.before_tick.connect(before_tick)
+	NetworkTime.after_tick_loop.connect(after_tick_loop)
+
+	#rollback ticks
+	if rollback_physics_space:
+		NetworkRollback.on_prepare_tick.connect(on_prepare_tick)
+	NetworkRollback.on_process_tick.connect(on_process_tick)
+
+func _exit_tree():
+	NetworkTime.before_tick.disconnect(before_tick)
+	NetworkTime.after_tick_loop.disconnect(after_tick_loop)
+
+	#rollback ticks
+	if NetworkRollback.on_prepare_tick.is_connected(on_prepare_tick):
+		NetworkRollback.on_prepare_tick.disconnect(on_prepare_tick)
+	NetworkRollback.on_process_tick.disconnect(on_process_tick)
+
+func _ready() -> void:
+	_init_physics_space()
+
+# Emitted before a tick is run.
+func before_tick(_delta: float, tick: int) -> void:
+	_snapshot_space(tick)
+	step_physics(_delta)
+
+func on_prepare_tick(tick: int) -> void:
+	if NetworkRollback._rollback_from == tick:
+		# First tick of rollback loop, rewind
+		_rollback_space(tick)
+	else:
+		# Subsequent ticks are re-writing history.
+		_snapshot_space(tick)
+
+func on_process_tick(_tick: int) -> void:
+	step_physics(NetworkTime.ticktime)
+		
+func after_tick_loop() -> void:
+	# Remove old snapshots
+	for i in snapshots.keys():
+		if i < NetworkRollback.history_start:
+			snapshots.erase(i)
+
+func step_physics(_delta: float) -> void:
+	# Break up physics into smaller steps if needed
+	var frac_delta = _delta / physics_factor
+	var rollback_participants = get_tree().get_nodes_in_group("network_rigid_body")
+	for i in range(physics_factor):
+		for net_rigid_body in rollback_participants:
+			net_rigid_body._physics_rollback_tick(frac_delta, NetworkTime.tick)
+
+		_physics_step(frac_delta)
+
+## Override this method to initialize the physics space.
+func _init_physics_space() -> void:
+	pass
+
+## Override this method to take one step in the physics space.
+## [br][br]
+## It should also flush and update all Godot nodes
+func _physics_step(_delta) -> void:
+	pass
+
+## Override this method to record the current state of the physics space.
+func _snapshot_space(_tick: int) -> void:
+	pass
+
+## Override this method to restore the physics space to a previous state.
+func _rollback_space(_tick) -> void:
+	pass