tests: restore the negative checks masked by stale fixtures (WP-B groups B-E)

Test-side only; no production, manifest or pin change. Group A identity
checks (test_source_pin and the jets.py pins) are unchanged and stay
failing as recorded.

B test_refined_dfg: receipt/plan fixtures load the frozen manifest JSON
  that verify_source returns for a matching tree (frozen_manifest), and
  the two manifest-selection assertions call verify_source with only its
  working-tree hash comparison neutralised (selected_manifest), so the
  malformed/collision/observation-mode/checkout receipt checks run again.
  test_source_pin remains the single identity check.
C test_channel_root: int(owner)-1 (uint64-int became float on NumPy 1);
  test_shifted_storage: FP32 NaN fill so the arrays stay FP32. Both reach
  the intended immutable/representation/FP32/density checks.
D test_block_stepper fake gets _ddf_shifting; test_fine_surface_gpu sets
  _boundary_hosts/_level_jets instead of the read-only fine_boundary view;
  test_refinement_followup fake_backend sets _layouts/_ddf_shifting/
  _level_cfgs instead of the read-only fine_layout view (as reviewed in
  32da2d73).
E test_kernel_contracts_reject_before_upload: an inconsistent pair tau is
  now first rejected by the hierarchy chain check; the test asserts that
  rejection, then bypasses _check_chain to prove the per-level omega/tau
  guard still rejects, and asserts no mem_alloc/memcpy_htod in either case.

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

tests/validation/multigrid/test_block_stepper.py

@@ -192,6 +192,7 @@ class CpuContracts(unittest.TestCase):
         backend._lock = RLock()
         backend._status = "ready"
         backend._step_count = 0
+        backend._ddf_shifting = False  # unshifted storage, as for the default config
         backend._stream = Mock()
         backend._module = Mock()
         backend._copy = backend._step = Mock()

tests/validation/multigrid/test_fine_surface_gpu.py

@@ -282,7 +282,8 @@ def test_fine_surface_four_hops(speed):
 @pytest.mark.parametrize("missing", ["surface_velocity_gpu", "link_exchange_gpu"])
 def test_missing_surface_device_buffer_rejects_before_launch(missing):
     backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
-    backend.fine_boundary = SimpleNamespace(objects=[object_spec(.002)])
+    backend._boundary_hosts = [None, SimpleNamespace(objects=[object_spec(.002)])]
+    backend._level_jets = [(), ()]
     backend._fine_curved = SimpleNamespace(fluid_idx_gpu=object(),
                                           surface_velocity_gpu=object(), link_exchange_gpu=object())
     setattr(backend._fine_curved, missing, None)

tests/validation/multigrid/test_refinement_followup.py

@@ -108,7 +108,9 @@ class FaultGuardsCPU(unittest.TestCase):
 
     def fake_backend(self):
         backend = PeriodicPatchStepper.__new__(PeriodicPatchStepper)
-        backend.fine_layout = None  # dense fine storage
+        backend._layouts = [None, None]  # dense storage on both levels
+        backend._ddf_shifting = False  # unshifted on every level, as _check_storage expects
+        backend._level_cfgs = [LBMConfig(nx=16, ny=16, viscosity=.1)] * 2  # ddf_shifting off
         backend.ctx = Mock(activate=nullcontext)
         backend._lock = RLock()
         backend._status = "ready"
@@ -158,10 +160,21 @@ class FaultGuardsCPU(unittest.TestCase):
             with self.assertRaisesRegex(RuntimeError, "four-cell"):
                 PeriodicPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)])
         p = implementation.FixedPatch2D.from_config(cfg, (4, 4, 12, 12))
-        with patch.object(cuda, "Stream"), patch.object(implementation.FixedPatch2D, "from_config",
-                                                       return_value=replace(p, tau_coarse=.9)):
-            with self.assertRaisesRegex(RuntimeError, "omega/tau"):
+        from CelerisLab.lbm import hierarchy
+        bad = patch.object(implementation.FixedPatch2D, "from_config",
+                           return_value=replace(p, tau_coarse=.9))
+        # A pair tau inconsistent with its level config is rejected twice over, both before
+        # any device allocation or upload: first by the hierarchy chain check, and, if that
+        # is bypassed, by the per-level omega/tau check in _build_level.
+        with patch.object(cuda, "Stream"), bad, patch.object(cuda, "mem_alloc") as alloc, \
+                patch.object(cuda, "memcpy_htod") as upload:
+            with self.assertRaisesRegex(RuntimeError, "config chain is inconsistent"):
                 PeriodicPatchStepper(cfg, context=context, refinements=[p.bounds])
+            with patch.object(hierarchy, "_check_chain"), \
+                    self.assertRaisesRegex(RuntimeError, "omega/tau"):
+                PeriodicPatchStepper(cfg, context=context, refinements=[p.bounds])
+            alloc.assert_not_called()
+            upload.assert_not_called()
         module = Mock()
         module.get_global.return_value = (Mock(), 16)
         with patch.object(cuda, "Stream"), patch.object(compiler, "generate_config"), \