Give the gas planet surface its own background shader (#51)

lunar_surface.gdshader recoloured was the whole gas surface backdrop,
so a landed gas giant read as regolith - the crater field never went
away, just changed colour. New gas_surface.gdshader replaces it for
gas profiles only: a nearest-row-wins horizontal band field (same
single-scalar discipline as lunar's nearest-crater field), with
drifting per-row turbulence so the bands ripple instead of reading as
ruled lines. Keeps the exact same uniform interface as lunar
(camera_cell/camera_frac/camera_zoom/viewport_size/cell_size/
base_color/crater_color/highlight_color), so LunarBackground.gd needs
no changes at all.

PlanetSurfaceProfile gains background_shader (default null = keep the
scene's existing lunar shader); PlanetSurfaceController._compose_surface()
swaps the background material's shader in only when a profile names one.
GasSurfaceProfile.tres points at the new shader and retunes its palette
to a deep-atmosphere/shadowed-band/lit-crest read; RockySurfaceProfile.tres
is untouched, so the rocky surface renders exactly as before.

Precision: every hash input is either an exact integer cell/row index or
a bounded [0,1) local fraction, same split as lunar_surface.gdshader and
Starfield.gd use for the same reason (world coordinates reach the tens of
thousands, where mobile float precision collapses). TIME-based lateral
drift is folded into the lattice coordinate via the same floor/remainder
trick rather than ever being added to a large cell index directly - see
combine_lattice()'s header note.

Tests: new tests/test_surface_profiles.gd (rocky resolves no
background_shader and keeps the lunar shader; gas resolves and applies
its own, different from lunar's). Full suite: 78/78 passed. Screenshot
of the gas surface confirms drifting bands with no craters, rendered
well inside the softpipe performance budget (20 frames in ~2m40s,
against lunar's "minutes per frame" baseline the ticket warns about).

Repo notes for the next agent, confirmed empirically this session:
- Never reference a plain (non-autoload) class_name class by its bare
  global name from a -s entry-point test script - `load()` it by path
  into a local var instead, same as PlanetSurfaceController.gd and
  PlanetSetups.gd already do for exactly this reason. Doing it the
  unsafe way here didn't fail to compile - it corrupted something in
  the resource-loading state badly enough that an UNRELATED scene's
  Rock.tscn lost its script attachment and RockField's rock-spawning
  loop exhausted the physics server's entire RID pool. If a test's
  crash trace implicates code you never touched, check every bare
  global class_name reference in the test first.
- Running a `tests/screenshot.sh` render (Mesa softpipe, genuinely
  minutes for a crater-shader scene) at the same time as a
  `run_tests.sh` full-suite run starves both for CPU on this device -
  kill one before waiting on the other rather than running them
  concurrently.

🤖 Generated with Claude Code

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

tests/test_surface_profiles.gd

@@ -0,0 +1,98 @@
+extends SceneTree
+
+# Headless gameplay test: run with
+#   godot --headless -s res://tests/test_surface_profiles.gd
+# Forgejo #51: a landed gas giant needs its own background shader instead of
+# lunar_surface.gdshader recoloured (craters reading as regolith, not
+# atmosphere). Verifies:
+#   1. the gas profile resolves a background_shader different from rocky's
+#      (rocky's stays null - "keep the scene's existing shader")
+#   2. PlanetSurfaceController._compose_surface() actually swaps the
+#      background material's shader when landing on a gas giant
+#   3. landing on a rocky planet leaves the scene's own lunar shader in
+#      place - a null background_shader is a no-op, not a forced reset
+#
+# PlanetSurfaceController's _ready() (which calls _compose_surface()) does
+# not fire synchronously inside add_child() for a -s entry-point script -
+# it's deferred to the next frame, same as ResourceReadout's was for #49 -
+# so every read of the composed shader below waits a frame after add_child()
+# rather than checking on the same one.
+
+var game_state: Node
+var lunar_shader: Shader
+var gas_shader: Shader
+var rocky_shader_after_compose: Shader
+var scene: Node
+var stage: int = 0
+var elapsed: float = 0.0
+
+
+func _initialize() -> void:
+	game_state = root.get_node("GameState")
+	lunar_shader = load("res://lunar_surface.gdshader")
+
+	# Loaded by path into a local, not referenced by its bare global
+	# class_name - same load-order hazard PlanetSetups.gd and
+	# PlanetSurfaceController.gd already work around: the class_name cache
+	# isn't guaranteed warm before an import pass has run.
+	var surface_profiles: Script = load("res://PlanetSurfaceProfiles.gd")
+	var rocky_profile: Resource = surface_profiles.get_profile("rocky")
+	var gas_profile: Resource = surface_profiles.get_profile("gas")
+	if rocky_profile.background_shader != null:
+		print("TEST_SURFACE_PROFILES: FAIL (rocky profile sets a background_shader - it should stay null)")
+		quit(1)
+		return
+	if gas_profile.background_shader == null:
+		print("TEST_SURFACE_PROFILES: FAIL (gas profile has no background_shader set)")
+		quit(1)
+		return
+	gas_shader = gas_profile.background_shader
+	if gas_shader == lunar_shader:
+		print("TEST_SURFACE_PROFILES: FAIL (gas profile points at the lunar shader, not its own)")
+		quit(1)
+		return
+
+	game_state.planet_definition_id = "rocky"
+	scene = load("res://PlanetSurface.tscn").instantiate()
+	root.add_child(scene)
+
+
+func _process(delta: float) -> bool:
+	elapsed += delta
+	match stage:
+		0:
+			if elapsed < 0.2:
+				return false
+			var rocky_bg: ShaderMaterial = scene.get_node("BackgroundLayer/LunarBackground").material
+			rocky_shader_after_compose = rocky_bg.shader
+			scene.free()
+
+			game_state.planet_definition_id = "gas_giant"
+			scene = load("res://PlanetSurface.tscn").instantiate()
+			root.add_child(scene)
+			elapsed = 0.0
+			stage = 1
+			return false
+		1:
+			if elapsed < 0.2:
+				return false
+			var gas_bg: ShaderMaterial = scene.get_node("BackgroundLayer/LunarBackground").material
+			scene.free()
+
+			if rocky_shader_after_compose != lunar_shader:
+				print("TEST_SURFACE_PROFILES: FAIL (landing on a rocky planet changed the background shader)")
+				quit(1)
+				return true
+			if gas_bg.shader != gas_shader:
+				print("TEST_SURFACE_PROFILES: FAIL (landing on a gas giant did not swap in gas_surface.gdshader)")
+				quit(1)
+				return true
+			if gas_bg.shader == lunar_shader:
+				print("TEST_SURFACE_PROFILES: FAIL (gas surface still uses the lunar shader)")
+				quit(1)
+				return true
+
+			print("TEST_SURFACE_PROFILES: PASS")
+			quit(0)
+			return true
+	return false