When the active snapshot carries a VgpuHostInfo matching a GPU (by
UUID, with a hostname + gpu_name fallback for remote metrics missing
a UUID), the frame renderer emits a compact vGPU block directly under
the parent GPU line. The block reports host mode, scheduler policy,
ARR state, instance count, and a per-instance row showing type name,
utilization, memory usage, VM id, and active/idle indicator.

Bare-metal GPUs have no matching record so the section is entirely
invisible — no empty placeholder, no header.

Refs #129

Add a VgpuMetricExporter that emits one metric family per vGPU
concern: all_smi_vgpu_host_mode, _scheduler_state, _scheduler_policy
at the host level, and _utilization, _memory_utilization,
_memory_used_bytes, _memory_total_bytes, _active per instance. Every
line carries gpu_index / gpu_uuid / gpu / instance / host labels; per-
instance lines additionally carry vgpu_id / vgpu_uuid / vgpu_type. The
exporter writes nothing when the vgpu_info slice is empty, so non-vGPU
hosts stay completely silent on the /metrics endpoint.

Teach the remote metrics parser to recognise the same families and
reconstruct VgpuHostInfo records, keyed by (gpu_uuid, vgpu_id) for
instances and by gpu_uuid for host-scope metrics. The resulting
Vec<VgpuHostInfo> now flows through the network client and into the
AppState via the remote collector, completing the
producer-exporter-consumer round trip.

Refs #129

Add a vGPU template module that, when ALL_SMI_MOCK_VGPU is set in the
mock server's environment, appends the full vGPU metric family
collection to NVIDIA node responses. Each mock GPU gets four synthetic
vGPU instances whose framebuffer totals sum to the parent GPU memory
and whose utilization / memory / active state varies per render cycle.

The env var gate preserves the default bare-metal mock behaviour, so
existing test suites are unaffected unless they explicitly opt in.
Add a cross-crate integration test that renders exporter-shaped
metrics text, parses it, and asserts every field round-trips
faithfully (including the 'no data line for missing utilization' case).

Refs #129

The NVIDIA reader already collects vgpu_vm_id and the TUI renders it as
the "vm=" column, but the Prometheus exporter never emitted the field,
so a remote all-smi scraping another all-smi reconstructed vm_id as an
empty string. This broke the PR's claimed "remote surfaces the exact
same view" property.

Emit vgpu_vm_id as an extra instance label and read it back on the
parser side. Update the mock template to include the label so the mock
server mirrors the new contract, and extend the vgpu_integration_test
round-trip to assert the field survives.

MetricBuilder::metric already escapes backslash, double-quote, and
newline per the Prometheus exposition spec, but a stray carriage
return in a label value (e.g. Windows-origin firmware strings) would
pass through literally. Downstream scrapers treat \r as a line
terminator on Windows, so an unescaped CR could split one metric
into two and let the tail be reinterpreted as attacker-controlled
content. Escape it to \\r to match the existing \\n handling.

active_vgpus_ffi previously trusted the count NVML wrote during the
probe phase and passed it straight to vec![0; count as usize]. A
misbehaving or hostile driver returning u32::MAX would drive an
instant ~16 GiB allocation. Clamp to MAX_VGPU_INSTANCES_PER_DEVICE
(256, well above any real deployment) and bail out to an empty vec
when exceeded. Introduce a distinct count_in for the fetch call so
the buffer capacity stays explicit and defensively clamp the
post-call truncate length to the allocated buffer size.

export_instance_metrics used to call iter_instances five times per
scrape (once per metric family). Each call rebuilt every gpu_index
and instance_id string, producing ~5 * 2 * N allocations per scrape
for N vGPUs. Collect the flattened (host, vgpu, gpu_index_str,
instance_id_str) tuples into a Vec<Row> once and iterate over
borrowed slices for each family. Cuts per-scrape allocation count
by 4x and keeps the exposition output byte-for-byte identical.

Every other metric family in parse_metrics was already guarded by
MAX_DEVICES_PER_TYPE=256, but the vGPU path had no bound. A malicious
remote exporter could advertise unbounded gpu_uuid / (gpu_uuid,
vgpu_id) values and drive VgpuParseState.hosts and .instances to
exhaust memory. Introduce MAX_VGPU_HOSTS=256 and
MAX_VGPU_INSTANCES=4096 (~16 vGPUs * 256 hosts) and gate only the
new-key insertion path so scrapes that legitimately update existing
entries are unaffected. Add two regression tests that push past each
cap and assert the extras are silently dropped without panicking.

parse_labels naively split on every comma, which a VM-owner-controlled
label value containing `",` could use to break out and inject fake
labels (e.g. forging a `host=` key to misattribute metrics to another
host). Combined with H-1, this unlocked cross-host metric spoofing.
Introduce split_labels_respecting_quotes to honour double-quoted
values and backslash escapes, and unescape_label_value to reverse the
`\\`, `\"`, `\n`, and `\r` sequences produced by
MetricBuilder::metric. Add regression tests covering comma-injection
and the newline/carriage-return round-trip.

Document all eight vGPU Prometheus metric families (host-level host_mode,
scheduler_state, scheduler_policy; per-instance utilization,
memory_utilization, memory_used_bytes, memory_total_bytes, active) with
complete label sets and descriptions. Add PromQL query examples for vGPU
monitoring, note on ALL_SMI_MOCK_VGPU env var, note 12 in the API Notes
section, get_vgpu_info() in the library API table, and a changelog entry
for the upcoming release in README.