The pytest-parallel plugin forks a worker process after test collection.
If CUDA is initialized before the fork (during collection), all CUDA
operations in the forked worker fail with "Cannot re-initialize CUDA".

Fix: Use nvidia-smi instead of torch.cuda for GPU counting in
validate_gpu_requirements(). This avoids CUDA initialization during
the collection phase.

The class-scoped fixture was causing "Cannot copy out of meta tensor"
errors when multiple threads tried to load SentenceTransformer
simultaneously. Changed to session-scoped with thread-safe initialization
using a lock and global cache, matching the pattern used for model_pool.

When tests run in parallel and all GPUs are occupied by workers that are
in use by other tests, launch_workers now waits (up to 5 min) for GPUs
to become available instead of failing immediately.

The key changes:
- _launch_workers_unlocked now returns None when GPUs unavailable after
  eviction (all workers in use), signaling retry is needed
- launch_workers has a polling loop that releases the lock while waiting,
  allowing other tests to release their workers

This fixes PD tests being skipped when run in parallel with other tests
that temporarily hold all available GPUs.

Add logging to every early check in _setup_pd_backend to diagnose
why PD tests are being skipped. Now logs:
- sgl_kernel import success/failure
- torch import success/failure
- CUDA availability
- GPU count vs requirements

This will show exactly which check is causing the skip.

PD workers are no different from embedding workers - they just need
to be launched. The early checks (sgl_kernel, torch, cuda, gpu count)
were unnecessary and causing skips.

Embedding workers work without these checks - they just get launched
on-demand and fail properly if something's wrong. PD should work the
same way.

Use pytest's config.option instead of parsing sys.argv, which is
fragile and doesn't handle options from pytest.ini/pyproject.toml.

Make get() wait for GPUs to become available instead of failing
immediately when all GPUs are in use by other tests:

- Add wait_for_gpus and gpu_wait_timeout parameters to get()
- Change _get_unlocked() to return None when GPUs unavailable (signals retry)
- Change _ensure_gpu_available() to return bool instead of raising
- Add polling loop in get() that releases lock while waiting

This matches the existing wait mechanism in launch_workers() and allows
parallel tests to share GPUs by waiting for each other.

Include %(threadName)s in log format so logs from different parallel
test threads can be distinguished. Shows 'MainThread' for sequential
execution and 'Thread-N' for parallel workers.