config: route parallel config-leaf reads through get_parallel() (#33170)

The parallel namespace joins the accessor migration: 106 config-leaf reads
(enable_dp_lm_head, enable_dp_attention, pp_async_batch_depth, dp_size,
ep_join_rank_offset, dwdp_size, ...) flip from get_server_args()/
self.server_args to get_parallel(), which serves config leaves from the
published parallel bag via __getattr__.

- ParallelContext.__getattr__ is restructured to stay dynamo-traceable
  (object.__getattribute__ graph-breaks): gate helpers such as
  enable_moe_dense_fully_dp() run inside compiled model forwards. A
  fullgraph regression test pins the pattern.
- The five live-shadowed topology sizes (tp/pp/dcp/attn_cp/moe_dp_size)
  keep their server_args reads: the live @property wins on the accessor,
  and conditionally-initialized groups would fail loud at unconditional
  call sites.
- Elastic-EP scale writers (ep_size/dp_size x4 in model_runner) reroute
  to get_context().override together with their remaining instance
  readers (expert_location gpus-per-node paths); the ServerArgs.override
  ratchet drops 39 -> 35.
- The expert placement helpers (compute_logical_to_rank_dispatch_
  physical_map, _compute_logical_to_all_physical_map,
  _prefer_same_node_experts) now read everything from the bags and drop
  their server_args parameter; their unit tests publish the config they
  need instead of stubbing it.

test/registered/unit/test_runtime_context.py

@@ -760,6 +760,33 @@ class TestForwardFlags(_IsolatedServerArgs):
             self.assertEqual(probe(torch.zeros(())).item(), 28)
         self.assertEqual(probe(torch.zeros(())).item(), 0)
 
+    def test_parallel_config_leaves_trace_under_torch_compile(self):
+        # Regression: parallel config leaves resolve through
+        # ``ParallelContext.__getattr__`` (the bag fallback), and gate helpers
+        # such as ``enable_moe_dense_fully_dp()`` read them inside compiled
+        # model forwards — the fallback body must stay dynamo-traceable
+        # (``object.__getattribute__`` graph-breaks). fullgraph=True turns any
+        # graph break back into a failure.
+        import torch
+
+        from sglang.srt.runtime_context import get_parallel
+
+        reset_context()
+        with get_context().override_server_args(moe_dense_tp_size=1, dwdp_size=4):
+
+            @torch.compile(fullgraph=True, backend="eager", dynamic=False)
+            def probe(x):
+                par = get_parallel()
+                if par.enable_prefill_context_parallel:
+                    x = x + 1
+                if par.moe_dense_tp_size == 1:
+                    x = x + 2
+                if par.dwdp_size > 1:
+                    x = x + 4
+                return x
+
+            self.assertEqual(probe(torch.zeros(())).item(), 6)
+
     def test_graph_visible_flags_are_process_visible_across_threads(self):
         # Documented divergence from the contextvar-backed flags: plain slots
         # are process-global (the storage form these flags had before the