Add gdb.testsuite/slot-pool-lock.exp covering the lock primitives in
lib/gdb-utils.exp that with_rocm_gpu_lock is built on.  The test
spawns tclsh children so it exercises the file locks across real
processes; each child appends timestamped acquire/hold/release
events to a shared log that the driver inspects.

Properties checked:

  * shared-capacity   - N shared acquirers hold concurrently within
                        a single pool's slot count.
  * mutex             - exclusive waits for the shared holder to
                        release before acquiring.
  * multi-pool-spread - row-major fill places the first NPOOLS
                        shared acquirers on distinct pools.
  * writer-priority   - a queued exclusive blocks new shared
                        acquirers, so a late shared arrival cannot
                        slip in when the pool drains; it must wait
                        for the exclusive to complete.
  * error-releases    - an error raised inside with_shared_lock_multi
                        propagates and releases the slot, so the
                        next acquire is immediate.

This commit is validation-only and adds no callers of the lock
layer beyond the new test.

Mark 60 gdb.rocm tests as parallel-safe and wrap two more in
with_rocm_gpu_lock so they participate in the shared lock at all.

For each parallel-safe test, add

    set rocm_gpu_concurrency parallel

just below "load_lib rocm.exp", which lets with_rocm_gpu_lock take a
shared slot instead of locking the whole GPU.  The marked tests all
launch a single small kernel and only inspect per-inferior state, so
they can safely share a GPU with other rocm tests up to the
configured slot count.

simple-outside-debugger.exp and mi-attach.exp did not previously
call with_rocm_gpu_lock at all, so they ran without any coordination
against the rest of the suite even though both do exercise the GPU.
Wrap the GPU-using portion of each in with_rocm_gpu_lock and opt in
to shared mode as well.

The remaining wrapped tests (precise-memory*, device-attach,
device-interrupt, fork-exec-*, multi-inferior-*,
step-schedlock-spurious-waves, load-core-remote-system) are
intentionally left unmarked and continue to take the exclusive
(per-GPU) lock, since they exercise device-wide state, run hog
kernels, or require multiple concurrent GPU inferiors.
maint-print-registers.exp is left untouched because it is a pure
host-side test with no GPU launch.

Add a "ROCm GPU Parallel Testing" section to gdb/testsuite/README
describing the knobs that govern how gdb.rocm tests share GPUs under
GDB_PARALLEL.

The per-test ::rocm_gpu_concurrency marker selects one of three
modes: parallel (one slot on any GPU), serial (the default; every
slot of one GPU, leaving other GPUs free), and machine (every slot
of every active GPU).  The section also documents the
hip_devices_support_debug_multi_process failsafe that downgrades
parallel to serial on devices that cannot host two debugged
processes at once.

The environment variables documented are:

  * ROCGDB_ROCM_PARALLEL_SLOTS - per-GPU concurrent-test cap
    (default 2), including the =1 setting that restores the
    historical "one rocm test per GPU" behaviour and the effect of
    higher values on serial-marked tests.

  * ROCGDB_ROCM_GPU_MAX_PARALLEL - cap on the number of active GPU
    pools (unset by default, meaning use every eligible GPU); lower
    it if kfd/dbgapi contention from many concurrent debug sessions
    produces spurious mid-run failures.

  * ROCR_VISIBLE_DEVICES - pre-set in the environment to restrict
    the lock layer to a chosen subset of the node's physical GPUs.
    Documents the pool-index -> physical-index mapping (pool 0 pins
    the first listed device, etc.), the interaction with
    ROCM_TEST_ARCH filtering, and the length-mismatch fallback to
    an identity map.

Round it out with the combined ceiling

    min(eligible_gpus, ROCGDB_ROCM_GPU_MAX_PARALLEL)
      * ROCGDB_ROCM_PARALLEL_SLOTS

on the number of concurrent rocm tests when every test is
parallel-marked.

runtime-core.exp ran six independent do_test invocations serially in
a single .exp file.  Each one regenerates a HIP coredump and restarts
GDB, so the file dominated gdb.rocm wall-clock time.

Move the shared body to runtime-core.exp.tcl and add one thin shard
per (fault, core_type, output_type) combination.  Each shard sets
the three parameters and sources the shared tcl, mirroring the
pattern used by gdb.base/all-architectures-*.exp and
gdb.arch/aarch64-sme-core-*.exp.

The shards still spawn HIP applications that crash and dump cores via
the runtime, which is sensitive to other rocm tests sharing the
device.  Each shard therefore acquires a whole GPU (the default
"serial" mode); other GPUs remain free, so shards still run in
parallel across devices.