Add `src/device/readers/nvidia_hardware.rs` with:
  * `HardwareDetailCache` memoising NUMA node id, GSP firmware mode,
    and GSP firmware version per device index (static values cached
    for the process lifetime, matching the thermal-threshold pattern
    introduced in PR #173).
  * `collect_nvlink_remote_devices` iterating up to `NVML_NVLINK_MAX_LINKS`
    and classifying the remote endpoint of every active link via raw FFI
    to work around a latent bug in nvml-wrapper 0.12.1's wrapper that
    writes to an immutable temporary.
  * `collect_gpm_metrics` that detects GPM support (Hopper+) but defers
    the two-sample handshake to a follow-up; the reader currently emits
    `Some(GpmMetrics::default())` on supported hardware so the TUI can
    show a "GPM-capable" hint without fabricating numeric readings.

Wire the new module into `NvidiaGpuReader` so every `get_gpu_info()` call
populates the new fields on supported devices while silently degrading to
the "unavailable" defaults on older drivers, non-datacenter SKUs, and the
nvidia-smi CSV fallback path.

Add `src/api/metrics/hardware.rs` with `HardwareMetricExporter`, emitting
six metric families for every GPU that populated at least one
hardware-detail field:
  * `all_smi_gpu_numa_node_id` (gauge; omitted when unknown)
  * `all_smi_gpu_gsp_firmware_mode` (gauge, 0/1/2)
  * `all_smi_gpu_gsp_firmware_version_info` (info-style, `version` label)
  * `all_smi_nvlink_remote_device_type` (one row per active link with
    `link_index` + `remote_type=gpu|switch|ibmnpu|unknown` labels)
  * `all_smi_gpu_sm_occupancy` (gauge 0-1, only when sampled)
  * `all_smi_gpu_memory_bandwidth_utilization` (gauge 0-1, only when sampled)

The exporter self-filters to GPUs that have any hardware-detail field
populated so non-NVIDIA paths and older-driver paths stay silent.
A supported-but-unsampled GPM snapshot (`Some(GpmMetrics::default())`)
produces no gauge lines to avoid publishing misleading zeros.

Row caching in `collect_rows` pre-computes the stringified `index` label
once per GPU so the six metric families iterate without re-allocating
labels, matching the vGPU / MIG exporter pattern.

Extend `MetricsParser::process_gpu_metrics` to handle the six issue-#132
metric families so remote-mode scrapes reconstruct the same `GpuInfo`
shape the local reader produces. Route `nvlink_*` lines through the
existing per-GPU accumulator via prefix-matching in the top-level
dispatcher.

Harden the parser against hostile remote input:
  * `MAX_NVLINK_PER_GPU = 32` caps the `nvlink_remote_devices` vector
    (current hardware tops out at 18 links; 32 leaves headroom).
  * `MAX_NUMA_NODE_ID = 4096` rejects absurd NUMA topologies.
  * `MAX_GSP_VERSION_LEN = 128` bounds the version string label.
  * GSP firmware mode accepts only 0..=2 (the values the exporter emits).
  * GPM fractions accept only `[0.0, 1.0]` — out-of-range readings drop
    so dashboards can distinguish "unavailable" from a real zero.
  * Duplicate `link_index` emissions coalesce (last-wins) rather than
    inflating the vector length.

Introduce `saturating_i32` as a counterpart to `saturating_u32` for the
signed NUMA node id field, plus `ensure_gpm_metrics` so partial GPM
payloads don't force-allocate an empty container on every GPU.

Add `render_hardware_details_row` producing a compact indented row under
each GPU when NUMA placement, GSP firmware mode/version, or NvLink
topology is reported. Format example:

  HW  NUMA:0  GSP:enabled v550.54.15  NVLink:6x(gpu=5,sw=1)

GPM gauges render inline on the same row (`GPM: SM=0.67 MemBW=0.42`) but
a supported-but-unsampled GPM snapshot produces nothing, matching the
exporter contract.

Extend `gpu_render_line_count` to include the new optional row so the
PgUp/PgDn layout math stays correct when rows grow from 2 to 4 lines
on hosts that populate every extended field. A new
`gpu_has_hardware_details_row` predicate drives both the renderer and the
line-count calculation so the two paths cannot drift.

Add `add_hardware_detail_metrics` to the NVIDIA mock generator so the
mock server exposes representative values for every issue-#132 metric
family:
  * NUMA node alternates between 0 and 1 across GPUs (replicates a
    dual-socket host with even-split GPU topology).
  * GSP firmware enabled, version `550.54.15` (matching a recent R555
    datacenter driver).
  * 6 active NvLinks per GPU — 5 remote=gpu + 1 remote=switch —
    mirroring typical HGX 8-GPU board topology.
  * GPM gauges at fixed plausible values (SM=0.67, MemBW=0.42).

Fixed rather than randomised values keep the mock output stable across
scrapes; hardware details never change at runtime on real devices, and
stable mock values simplify downstream test assertions.

Mirror the vGPU / MIG integration-test pattern: build Prometheus
exposition snippets that match the exporter output byte-for-byte, run
them through `MetricsParser::parse_metrics`, and assert every
hardware-detail field survives the round trip.

Coverage:
  * Full happy-path round-trip preserves NUMA, GSP mode + version,
    all 6 NvLinks with correct classification counts, and both GPM
    gauges.
  * Partial scrape (NUMA only) preserves absence of the other fields.
  * Non-NVIDIA scrape leaves every new field at its "unavailable"
    default.
  * Unknown and IBM NPU NvLink remote types round-trip intact.
  * Parser caps the per-GPU NvLink vector at 32 against a hostile
    40-link emission.
  * Out-of-range GSP firmware mode (99) and GPM fractions (9.9) are
    dropped so dashboards never render impossible values.
  * Partial GPM emission populates only the reported field.

…tion

Narrow the early-exit in collect_nvlink_remote_devices to only break on
known past-the-end variants (InvalidArg, NotSupported). Transient errors
(Unknown, GpuLost) now skip the current link index with continue so that
a driver hiccup on link N does not silently hide links N+1 through MAX.

Add value.fract() == 0.0 guard to the gpu_gsp_firmware_mode branch so
fractional inputs like 1.5 (which would silently saturate to 1) are dropped
instead of stored as a wrong mode code. Apply the same guard to
gpu_performance_state for consistency.

A malicious remote Prometheus endpoint could embed ANSI escape sequences
in the version label (e.g. ESC[2J ESC[H). Without a character filter the
TUI would execute those sequences on render. Add a chars().all(|c|
!c.is_control()) guard so any version string containing control characters
is dropped and the field stays None.

Collapse nested if-let in get_or_fetch_field probe path (collapsible_if)
and convert useless format! to .to_string() in control-char test.

Add NVIDIA Hardware Details Metrics section to API.md covering the six
new Prometheus series (NUMA node, GSP firmware mode, GSP firmware version
info, NvLink remote type, GPM SM occupancy, GPM memory bandwidth util)
with label tables and absence semantics.

Update README.md NVIDIA feature bullet, API mode metrics list, mock
server note, and v0.21.0 changelog entry to reflect the hardware details
additions from issue #132.