sim/mujoco: add concurrency stress test for _require_no_running_policy mutation guard

[cagataycali]

Problem

The mutation guard (_require_no_running_policy) is the load-bearing safety
mechanism that stops the LLM from scheduling a scene mutation while a policy
worker is mid-step. If it has a race, we get SIGSEGV on stale model/data
pointers.

We currently trust that:

1. self._policy_threads[robot_name] = future and any(not f.done() for f in ...) are atomic enough in practice
2. The executor's submit() of the policy worker happens-before the next
   mutation's check (i.e. the dict assignment is visible before
   _require_no_running_policy runs)
3. A policy worker finishing and setting its future to done() doesn't race
   with a mutation that checks "is anything running" mid-transition

No test proves any of this.

Proposal

Add tests/simulation/mujoco/test_concurrency.py:

• Test 1: mutation-during-policy rejected. Start a policy that runs for ~5
  seconds. From the main thread, rapidly call set_gravity() 1000x. Assert:
  every single call returns a friendly error, none succeed, no segfault.
• Test 2: rapid start→stop→start→stop. Stress the future lifecycle. Assert
  _policy_threads state stays consistent.
• Test 3: mutation accepted immediately after policy completes. Assert
  that once the future is done, the very next mutation succeeds — no
  lingering state.

Use a cheap mock policy (lambda obs: {"qpos": [0]*n}) so the stress loop
doesn't take minutes.

Acceptance

• Tests marked pytest.mark.slow if needed (run in hatch run test-integ)
• Or keep fast enough for hatch run test if the mock is trivial
• Any discovered races get fixed + regression-tested before closing this issue

---

Surfaced by a second-opinion review of PR #85.

[cagataycali]

Landed on PR #85 in commit 5c11959.

Tests added in new TestMutationGuardStress class:

• test_1000_set_gravity_calls_during_policy_never_segfault -- 1000 concurrent mutations + live policy, asserts no crash and at least one blocked-status
• test_rapid_start_stop_start_stop_policy -- 10 cycles of start/stop, asserts _policy_threads stays clean each iteration
• test_mutation_accepted_immediately_after_policy_completes -- no lingering guard state
• test_concurrent_policies_stress_no_deadlock -- two concurrent policies + 500 main-thread mutations don't deadlock on self._lock

Each test asserts well-formed dict responses (no crashes), specific status invariants, and the uniform 'policy is running' error shape when blocked.

Will close on PR #85 merge.