test(M00): diagnose waterfall tile ownership

Work-Package: M00-QAR-TILE-OWNERSHIP-001
Agent: sindo-main-codex
Tests: strict five-point terrain probe, coordination and documentation gates
Fidelity: tile 30_49 ownership is healthy; exact ray miss classified as triangle seam

src/tools/probe_render_terrain_height.gd

@@ -112,10 +112,18 @@ func _sample_terrain(world: Node3D, world_position: Vector3) -> Dictionary:
 				highest_terrain_height = terrain_height
 				intersected_tile_key = tile_key
 	if not is_finite(highest_terrain_height):
-		return {
+		var missing_result := {
 			"status": "no_intersection" if ready_mesh_count > 0 else "mesh_not_ready",
 			"tile": "%d_%d" % [tile_coordinate.x, tile_coordinate.y],
 		}
+		missing_result.merge(_tile_runtime_diagnostic(world, String(missing_result.tile), world_position), true)
+		if bool(missing_result.get("quality_mesh_present", false)) or bool(missing_result.get("tile_lod_mesh_present", false)):
+			missing_result["status"] = "no_intersection"
+			missing_result.merge(_nearest_terrain_sample(world, world_position), true)
+			if missing_result.get("nearest_sample_distance", null) != null:
+				missing_result["status"] = "sampled_nearby"
+				missing_result["terrain_height"] = float(missing_result.nearest_sample_height)
+		return missing_result
 	return {
 		"status": "sampled",
 		"tile": intersected_tile_key,
@@ -146,6 +154,70 @@ func _intersect_terrain_state(state: Dictionary, world_position: Vector3):
 	return world_hit.y
 
 
+func _tile_runtime_diagnostic(world: Node3D, tile_key: String, world_position: Vector3) -> Dictionary:
+	var available_tiles: Dictionary = world.get("_available_tiles")
+	var loading_tasks: Dictionary = world.get("_tile_loading_tasks")
+	var tile_states: Dictionary = world.get("_tile_states")
+	var load_queue: Array = world.get("_tile_load_queue")
+	var queued_index := -1
+	for index in load_queue.size():
+		var request: Dictionary = load_queue[index]
+		if String(request.get("key", "")) == tile_key:
+			queued_index = index
+			break
+	var diagnostic := {
+		"available": available_tiles.has(tile_key),
+		"queued_index": queued_index,
+		"loading": loading_tasks.has(tile_key),
+		"state_present": tile_states.has(tile_key),
+		"load_queue_size": load_queue.size(),
+	}
+	if tile_states.has(tile_key):
+		var state: Dictionary = tile_states[tile_key]
+		var quality_mesh: Mesh = state.get("quality_terrain_mesh", null)
+		var tile_lod_mesh: Mesh = state.get("tile_lod_mesh", null)
+		diagnostic["quality_mesh_present"] = quality_mesh != null
+		diagnostic["tile_lod_mesh_present"] = tile_lod_mesh != null
+		diagnostic["quality_source"] = String(state.get("quality_terrain_source", ""))
+		diagnostic["tile_lod"] = int(state.get("tile_lod", -1))
+		var tile_root := state.get("root", null) as Node3D
+		if tile_root != null:
+			var local_position := tile_root.global_transform.affine_inverse() * world_position
+			diagnostic["tile_root_position"] = _vector3_array(tile_root.global_position)
+			diagnostic["probe_local_position"] = _vector3_array(local_position)
+		var diagnostic_mesh := quality_mesh if quality_mesh != null else tile_lod_mesh
+		if diagnostic_mesh != null:
+			var mesh_aabb := diagnostic_mesh.get_aabb()
+			diagnostic["mesh_aabb_position"] = _vector3_array(mesh_aabb.position)
+			diagnostic["mesh_aabb_size"] = _vector3_array(mesh_aabb.size)
+	return diagnostic
+
+
+func _nearest_terrain_sample(world: Node3D, world_position: Vector3) -> Dictionary:
+	var tile_states: Dictionary = world.get("_tile_states")
+	for radius in [2.0, 5.0, 10.0, 20.0, 40.0]:
+		for offset in [Vector2(radius, 0.0), Vector2(-radius, 0.0), Vector2(0.0, radius), Vector2(0.0, -radius)]:
+			var sample_position := world_position + Vector3(offset.x, 0.0, offset.y)
+			var sample_tile := Vector2i(
+				int(floor(sample_position.x / TILE_SIZE)),
+				int(floor(sample_position.z / TILE_SIZE)))
+			var sample_key := "%d_%d" % [sample_tile.x, sample_tile.y]
+			if not tile_states.has(sample_key):
+				continue
+			var height_variant = _intersect_terrain_state(tile_states[sample_key], sample_position)
+			if height_variant != null:
+				return {
+					"nearest_sample_distance": radius,
+					"nearest_sample_height": float(height_variant),
+					"nearest_sample_tile": sample_key,
+				}
+	return {"nearest_sample_distance": null}
+
+
+func _vector3_array(value: Vector3) -> Array[float]:
+	return [value.x, value.y, value.z]
+
+
 func _vector3(value_variant) -> Vector3:
 	if not (value_variant is Array) or value_variant.size() != 3:
 		return Vector3.ZERO