Allocate test ports dynamically from a non-ephemeral range - #2193

Test ports were fixed per sub-project from a base of 33278, shifted by an
optional GARNET_TEST_PORT_SLOT offset. That base predates the slot mechanism and
sits inside Linux's default outbound-connection range (32768-60999,
net.ipv4.ip_local_port_range), so on Linux the kernel could assign a test's port
to a connect() between the moment the port was observed free and the moment the
server bound it. Probing cannot close that window; only staying out of the range
can. The slot mechanism encoded 49152 as the ephemeral floor, which is the
Windows and macOS value, so slot 7 looked like the boundary case while slot 0 was
already unsafe on Linux. Windows and macOS were never affected, which is why the
flakes were Linux-only.

Ports now come from [16384, 32768), below every supported platform's ephemeral
range and above the crowded region that holds both ports a developer is likely to
be running (6379, 5432, 11211, 8080) and ports this suite itself uses
(10000-10002 Azurite). Each test host leases one aligned 32-port block, held by
an exclusively locked file for the life of the process, which is what keeps
concurrent hosts apart; the OS releases the lock on exit, crash, or kill, so a
block frees itself. The lease is taken first and the ports probed second, because
software outside the suite, or a server stranded by a killed run, holds ports
while holding no lease.

Blocks are searched from a start derived from the checkout and the project name,
so a project returns to the same ports run after run and netstat output stays
interpretable. On collision the search advances by a stride derived from the
process, so two hosts that start at the same block diverge rather than walking in
lockstep. The stride is forced odd and the block count is a power of two, which
together make the walk visit every block exactly once: completing it proves no
block is free rather than exhausting a retry budget. The hash is
Utility.GetHashCodeWithMix, because the index is cut from the low bits that
HashBytes alone leaves unmixed.

This replaces slots entirely. Concurrency is no longer capped at seven
checkouts, GARNET_TEST_PORT_SLOT is gone and nothing needs setting, and
TestPortAssignment, ClusterPortAssignment, and the band-width invariants they
required are deleted - projects are identified by assembly name, so adding one
needs no central registration.

Special cases, each commented where it lives:
- Ports 30000-30999 are carved out for test/docker-tests/validate_docker_images.py,
  which allocates from its own fixed base and can run alongside this suite.
  TestPortAllocatorTests reads that base out of the Python file so moving either
  side without the other fails as a test.
- The probe binds the IPv4 and IPv6 wildcards separately and exclusively. One
  dual-mode socket handles IPv4-mapped addresses differently per platform, and a
  shared bind succeeds alongside a listener on a specific address under that
  wildcard.
- A failed probe deliberately ignores the socket error code: Windows reports
  AccessDenied for ports excluded by Hyper-V, WSL, or Docker, not
  AddressAlreadyInUse.
- Cluster nodes keep contiguous ports because node n binds base + n; block
  alignment keeps that run from straddling a boundary.
- GARNET_TEST_PORT_BASE pins a base port for reproduction or a fixed firewall
  opening. Pinned ports are still leased and probed.

GarnetServerTcp.Start now reports the endpoint and the operating system's reason
when a bind fails, which the raw SocketException names neither of.
TestUtils.OnTearDown adds the allocation context, so a conflict reads as software
outside the suite rather than as a defect in Garnet or in the test.

The skill still told readers to set GARNET_TEST_PORT_SLOT, which no longer
exists; test hosts now claim their ports without configuration.

Reserve's error paths decide whether a run stops clearly or proceeds on ports it
does not own, and none of them ran in an ordinary suite: a block another host
holds, a pinned base port, and every block exhausted. A regression in any of
them would surface as the silent cross-checkout corruption the allocator exists
to prevent.

Leases in these tests are redirected to a private directory. Holding blocks in
the shared one would stop concurrent runs in other checkouts from starting,
which is the very failure under test.

Writing them found a real defect in the first draft: two tests took the same
port from a deterministic helper, and because a reservation holds its lease for
the life of the process while binding nothing, the second saw ports that read as
free inside a block that was already leased. The helper now checks both, which
is the same distinction the allocator draws.

BuildPortConflictReport is split out of ReportPortConflictIfBindFailed so the
decision and the wording can be asserted without making a real test fail.

…ests

The fixture built its second listener from TestUtils.TestPort + 1. That is the
port TestUtils.AlternateTestPort returns, and it is inside the block this test
host leases, so the behavior is unchanged - but the arithmetic only works
because the reservation covers two ports, which the expression does not say.
Naming the property states the dependency the fixture actually has.