fix(client): entity lerp, fog shader safety, type fixes

Entity renderer: add framerate-independent position lerping so entities
slide between tiles instead of snapping. Tuned for Sprint snappiness
and Walk/Careful fluidity.

Fog shader: set ColorRect to transparent fallback so a shader load
failure doesn't paint solid white over the world. Track camera position
(not player position) so fog stays synced during smooth camera pan.
Restructure GLSL to avoid early return (some GPU drivers miscompile it).

Minor type fixes: typed Array[Vector2] in cursor_renderer tick drawing,
untyped Array in inventory_grid to avoid Godot typed-array cast issues.

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

client/scripts/rendering/entity_renderer.gd

@@ -5,6 +5,10 @@ extends Node2D
 # Creates/updates/removes ColorRect children based on entity data
 # Entity format (from Protocol v2): {entity_id, x, y, z, kind: {variant, data}, visibility}
 #
+# Position lerping: entity sprites smoothly slide between tiles instead of snapping.
+# The server moves entities in discrete tile steps; the lerp makes this look fluid.
+# Speed is tuned so Sprint feels snappy and Walk/Careful/Crouch feel deliberate.
+#
 # D-033 colors: Phase 1 defaults by entity kind. Phase 2 (#361) will derive
 # color from RelationshipState via the knowledge graph.
 
@@ -12,11 +16,31 @@ const TILE_SIZE: int = Constants.TILE_SIZE
 const ENTITY_SIZE: int = 24
 const ENTITY_OFFSET: float = (TILE_SIZE - ENTITY_SIZE) / 2.0  # center within tile
 
-var entity_nodes: Dictionary = {}  # entity_id -> Node2D mapping
+# Lerp speed — framerate-independent exponential smoothing.
+# At 12.0: ~70% there after 0.1s, ~95% after 0.25s.
+# Fast enough for Sprint snappiness, slow enough for Walk to show sliding.
+const LERP_SPEED: float = 12.0
+
+var entity_nodes: Dictionary = {}    # entity_id -> Node2D
+var _entity_targets: Dictionary = {} # entity_id -> Vector2 (target pixel position)
 
 func _ready() -> void:
 	print("EntityRenderer: Initialized")
 
+
+func _process(delta: float) -> void:
+	# Lerp all entity visual positions toward their targets each frame.
+	# Uses framerate-independent exponential smoothing.
+	var weight := 1.0 - exp(-LERP_SPEED * delta)
+	for entity_id in entity_nodes.keys():
+		if not _entity_targets.has(entity_id):
+			continue
+		var node = entity_nodes[entity_id]
+		var target: Vector2 = _entity_targets[entity_id]
+		if not node.position.is_equal_approx(target):
+			node.position = node.position.lerp(target, weight)
+
+
 # Update entities from snapshot data
 func update_entities(entities: Array) -> void:
 	var active_ids: Array = []
@@ -62,19 +86,28 @@ func _create_entity_node(entity_id: int, entity_data: Dictionary) -> void:
 	if entity_id == GameState.player_entity_id:
 		_add_facing_indicator(entity_node)
 
+	# Snap to initial position (no lerp on first appearance)
+	if entity_data.has("x") and entity_data.has("y"):
+		var target := Vector2(
+			floorf(entity_data.x) * TILE_SIZE + ENTITY_OFFSET,
+			floorf(entity_data.y) * TILE_SIZE + ENTITY_OFFSET
+		)
+		entity_node.position = target
+		_entity_targets[entity_id] = target
+
 	_update_entity_node(entity_id, entity_data)
 
-# Update an existing entity node (position, visibility dimming, facing)
+# Update an existing entity node (target position, visibility dimming, facing)
 func _update_entity_node(entity_id: int, entity_data: Dictionary) -> void:
 	if not entity_nodes.has(entity_id):
 		return
 
 	var entity_node = entity_nodes[entity_id]
 
-	# Update position from x, y fields (Protocol format), centered within tile.
+	# Update target position — the lerp in _process() will smoothly move there.
 	# Server sends tile-center coords (tile 16 → 16.5), floor to get tile index.
 	if entity_data.has("x") and entity_data.has("y"):
-		entity_node.position = Vector2(
+		_entity_targets[entity_id] = Vector2(
 			floorf(entity_data.x) * TILE_SIZE + ENTITY_OFFSET,
 			floorf(entity_data.y) * TILE_SIZE + ENTITY_OFFSET
 		)
@@ -100,6 +133,7 @@ func _remove_entity_node(entity_id: int) -> void:
 	var entity_node = entity_nodes[entity_id]
 	entity_node.queue_free()
 	entity_nodes.erase(entity_id)
+	_entity_targets.erase(entity_id)
 
 # D-033 color by entity kind — delegates to Constants.color_for_entity_kind
 static func _color_for_kind(entity_data: Dictionary) -> Color: