Port the 9 contact sensor tests from the PhysX backend test file,
adapting them to use isaaclab_ovphysx.sensors.ContactSensorCfg
(which wires class_type to the ovphysx ContactSensor).

Three tests that depend on track_friction_forces (not yet supported
in ovphysx v1) are marked @pytest.mark.skip.  The contact-time helper
is adapted to never enable track_contact_points or track_friction_forces
so the basic contact-time tests continue to provide real coverage.

Replace try/except/pass patterns with contextlib.suppress
as required by ruff SIM105 rule. Also add missing contextlib
import.

The post-articulation upstream uses changelog fragments under
source/<pkg>/changelog.d/; restore the direct CHANGELOG.rst and
extension.toml edits and add a minor-tier fragment that the nightly
CI workflow will compile.

Drop AppLauncher and the PhysX-style setup_simulation fixture in favour
of the kitless _ovphysx_sim_context helper (matches test_rigid_object.py
shipped in isaac-sim#5459) and the autouse device-lock fixture for ovphysx<=0.3.7.

Also drop the disable_contact_processing parametrize axis: toggling the
global Carbonite '/physics/disableContactProcessing' flag requires the
settings manager which is not available in kitless mode.  test_no_contact_reporting
now exercises the same semantic via a no-filter cfg instead.

The three v2-deferred tests (track_friction_forces / track_contact_points)
keep their pytest.mark.skip but their bodies are fully kitless so they
can be un-skipped once the ovphysx wheel ships the missing per-sensor
read APIs (see docs/superpowers/specs/2026-04-27-ovphysx-contact-api-gaps.md).

Run via:
    ./scripts/run_ovphysx.sh -m pytest source/isaaclab_ovphysx/test/sensors/test_contact_sensor.py -v

The PhysX-only PRIM_DELETION callback in
isaaclab.sensors.SensorBase._register_callbacks was gated on
'physx' in physics_mgr_cls.__name__.lower(), which also matches
OvPhysxManager.  In kitless ovphysx mode the resulting
'from isaaclab_physx.physics import IsaacEvents' raises
ModuleNotFoundError because omni.physics.tensors isn't loaded.

Switch to an exact name match so the import only fires for the
PhysX backend.  Add an isaaclab changelog fragment.

Fixes the test-time import error surfaced by
test_contact_sensor.py under ./scripts/run_ovphysx.sh.

Three places matched ovphysx as physx via substring 'physx in
manager_name.lower()'.  Switch to exact name matches and explicitly
raise on unknown managers:
  - SensorBase._register_callbacks (already fixed in prior commit;
    extended changelog)
  - AssetBase.set_debug_vis (omni.kit.app import gate)
  - SceneDataProvider._get_backend (factory dispatch)

Also broaden InteractiveScene.physics_scene_path to fall back to a
bare UsdPhysics.Scene prim (TypeName='PhysicsScene') when no prim
with PhysxSceneAPI is present.  Kitless ovphysx does not load the
omni.physx schema, so the scene prim only carries the stock USD
type.  PhysX-backed flows still prefer PhysxSceneAPI.

The ovphysx ContactBinding API explicitly states that no USD schema
beyond the rigid bodies themselves is needed for contact reporting
(ovphysx/api.py:2186-2189).  The PhysxContactReportAPI check was
copied verbatim from the PhysX backend but is irrelevant for ovphysx
and silently breaks the kitless flow where the PhysxSchema USD
plugin is not registered (so AddAppliedSchema('PhysxContactReportAPI')
in activate_contact_sensors is a no-op).

Switch the discovery loop to require UsdPhysics.RigidBodyAPI (the
USD-core rigid body schema, applied by the spawner regardless of
PhysX availability).  Update the error message accordingly.

This reverts commit 4652794.

The ovphysx wheel ships its own PhysxSchema USD plugin under
ovphysx/plugins/usd/PhysxSchema, but in kitless runs it is not
auto-registered (omni.physx normally does that in Kit-based runs).
Without registration, prim.AddAppliedSchema('PhysxContactReportAPI')
silently writes the schema name to the apiSchemas listOp but the wheel's
C++ contact-binding check fails to match the schema on the prim and
emits 'Failed to find contact report API at ...' — the binding then
returns sensor_count=0.

Register the plugin once in OvPhysxManager.initialize() (idempotent;
guarded by a class-level flag).  This is the canonical bootstrap for
any sensor that depends on Physx-prefix schemas under kitless ovphysx,
not just ContactSensor.

Also switch ContactSensor._initialize_impl's discovery check from the
filtered prim.GetAppliedSchemas() to the unfiltered
prim.GetPrimTypeInfo().GetAppliedAPISchemas() so the Python-side
discovery sees the same schemas the wheel does.  The filtered API
hides Physx-prefix schemas in kitless mode because the C++ schema
type registration only happens when the omni.physx plugin loads the
PhysxSchema library — distinct from the plugInfo.json registration we
just added.

clear_callbacks() reset _callback_id back to 0, so subsequent
register_callback() calls handed out IDs that collided with old
CallbackHandle.id values still held by not-yet-garbage-collected
sensors / assets.  When the old object's __del__ eventually ran it
deregistered the NEW callback by ID — leaving the new sensor's
_initialize_callback wired up but never fired.

The symptom under kitless OVPhysX was a sensor that registered its
callback, then PHYSICS_READY dispatched, then sensor.reset()
crashed with 'has no attribute _ALL_ENV_MASK' (init never ran).
The PhysX backend hid this because its callback registry is the
Carbonite event bus rather than this Python dict.

Keep _callback_id monotonic across clear_callbacks invocations to
preserve uniqueness for the lifetime of the process.

* Add 'ovphysx' field to PhysicsCfg in AnymalD flat_env_cfg.py
* Add 'ovphysx' field to VelocityEnvContactSensorCfg in velocity_env_cfg.py
* events.py randomize_rigid_body_material: explicit OvPhysxManager branch
  (no-op + warning; PhysX impl assumes root_view.link_paths which OvPhysx's
  per-tensor-type bindings dict does not satisfy)
* ContactSensor._initialize_impl: override _num_envs from binding sensor_count
  (clone_usd=False on OvPhysX leaves env_1..N out of USD, so the parent
  class's USD walk reports num_envs=1 even with N=4096 cloned physics envs)

… layout

ovphysx ContactBinding returns sensors in pattern-major order:
the flat index for (env, sensor) is sensor*num_envs + env, NOT the
PhysX env-major env*num_sensors + sensor that update_net_forces_kernel
inherited from the PhysX port.

Symptom on AnymalD locomotion: body indices were scrambled, so foot
contacts were attributed to the wrong body (often the base), tripping
Episode_Termination/base_contact and resetting episodes after ~4 steps.

Verified by inspecting cb.sensor_paths for a 3-env, 2-body scene:
  ['/World/envs/env_0/A', '/World/envs/env_1/A', '/World/envs/env_2/A',
   '/World/envs/env_0/B', '/World/envs/env_1/B', '/World/envs/env_2/B']
i.e. each per-body sensor pattern is fully expanded across envs before
the next pattern starts.

Pass num_envs through update_net_forces_kernel and switch its src_idx
to the pattern-major formula.

Existing tests are all single-body per ContactSensor; pattern-major
vs. env-major flat-buffer indexing collapses to the same address when
there is only one body, so they couldn't catch the kernel formula bug
fixed in the previous commit.

test_multi_body_per_sensor_indexing exercises a single ContactSensor
with prim_path='{ENV_REGEX_NS}/Cube_.*' that resolves to two cubes per
env (one on the ground, one floating).  After the scene settles, the
on-ground cube reports a non-zero net force and the floating cube
reports zero.  If the kernel indexing is wrong, the floating cube
picks up a phantom contact force from another env's grounded cube and
the assertion fires with a diagnostic message pointing at the
pattern-major / env-major mismatch.

Verified to fail (sum-abs ~3.0) on the pre-fix kernel and pass after
re-applying sensor*num_envs+env.

Two small fixes needed after the rebase onto current develop:

* ``isaaclab.utils`` no longer re-exports the ``configclass`` decorator
  directly; the import has to be ``from isaaclab.utils.configclass
  import configclass``. Touched ContactSensorCfg and the contact-sensor
  test module.
* The OVPhysX wheel is now invocable through the standard Kit Python
  entrypoint (``./isaaclab.sh -p``); the kitless ``run_ovphysx.sh``
  wrapper is no longer required. Updated the test-module docstring to
  reflect that.

Three small parity fixes that came out of a code review against the
PhysX/Newton implementations:

* Rename ``update_net_forces_kernel`` to
  ``update_net_forces_ovphysx_kernel``. PhysX ships a kernel of the same
  name with a different signature (env-major vs sensor-major index
  order); the explicit suffix prevents a confusing compile error if
  someone cross-imports.
* ``ContactSensor.body_names`` now returns ``list[str]`` (never ``None``)
  and raises a clear ``RuntimeError`` if accessed before initialization,
  matching the PhysX contract.
* Add ``_set_debug_vis_impl`` and a no-op ``_debug_vis_callback`` to the
  OVPhysX ContactSensor. The kitless OVPhysX flow has no Kit renderer,
  so the implementations log a one-shot warning and otherwise no-op,
  but the hooks are wired so ``cfg.debug_vis=True`` surfaces an
  explicit message instead of silently doing nothing.

The previous exact-name check (``manager_name == "NewtonManager"``)
broke ``NewtonMJWarpManager``, ``NewtonKaminoManager``,
``NewtonXPBDManager``, and ``NewtonFeatherstoneManager`` — all
subclasses of ``NewtonManager``. The original substring match handled
them; the exact-match check rejected them and fell into the catch-all
``ValueError`` raise.

Restore the original ``.lower()`` substring matching, but check the
``ovphysxmanager`` exact name *before* the substring branches: without
that ordering ``"physx" in "ovphysxmanager"`` would route OVPhysX to
the PhysX impl (which assumes a ``root_view`` with ``.link_paths``,
absent on OVPhysX's per-tensor-type bindings dict).

Reproduced locally by running
``test_rendering_dexsuite_kuka[newton-isaacsim_rtx-rgb]`` against the
contact-sensor branch — failed with the documented ``ValueError``
before the fix, passes the dispatch path after.