…ve chunk inside its cache

Squash of:
- Make Chunk abstract and give the unpooled fallback its own chunk class
- Split Magazine into a size-class magazine and a buddy magazine
- Drop buddy-shaped leftovers from the size-class allocation path
- Remove native-image reflection entries for fields no longer accessed reflectively
- Keep the fallback to a fresh chunk if the size-class cache ever hands out a full chunk
- Release a size-class chunk that fails an allocation instead of retrying it
- Let the size-class cache hold an active chunk at the head of its reusable list
- Keep a size-class magazine's current chunk inside its cache
- Describe the active chunk in the size-class cache documentation
- Test the size-class magazine's active chunk inside its cache
- Drop the size-classed chunk's magazine back-reference
- Tighten the size-class cache's assertions and comments
- Test the size-class magazine's active chunk by behaviour
- Pin chunk allocations and used memory on a seeded allocation trace
- Pin the unpooled fallback: accounted while alive, replaced on growth, freed on release
- Make the unpooled fallback a one-shot BuddyChunk

…to BuddyTree

Squash of:
- Pin buddy chunk reuse across rounds of the same large allocations
- Give each stripe its own buddy chunk cache
- Move the buddy tree of BuddyChunk into its own BuddyTree
- Test BuddyTree against a frozen copy of its current search
- Store the largest free order in each BuddyTree node

…ueue in one place

Squash of:
- Keep the size-class cache's active chunk off its lists
- Extract ChunkQueue from the size-class cache's two lists
- Record a size-classed chunk's cache membership as its ChunkQueue
- Extract PendingChunks from the size-class cache
- Decide a size-classed chunk's queue in one place, SizeClassedChunkCache.refile
- Fix comments left behind by the size-class queue refactor
- Keep ChunkQueue and PendingChunks links on Chunk

Squash of:
- Expose a BuddyTree's largest free order and whether it is wholly free
- Pin buddy chunk reuse after foreign releases, the idle bound, and cross-thread content
- File buddy chunks by their largest free block, without a concurrent map
- Bound only the wholly free buddy chunks by CHUNK_REUSE_QUEUE
- Describe the allocator as it is now, and derive chunk geometry in the buddy tests
- Allocate from the buddy chunk with the largest free block

…blocks in place

Squash of:
- Bound the idle size-classed chunks by the retention floor, not every chunk
- Revert "Bound the idle size-classed chunks by the retention floor, not every chunk"
- Bound the chunk recycler by one byte budget per heap
- Bound a buddy magazine's idle chunks in bytes
- Let a buddy release act in place when the stripe lock is free

…ool per chunk size

Squash of:
- Give the size classes from 32 KiB up chunks of 8 segments
- Skip this magazine's own cache when draining the heap's pending notes
- Retain one chunk per size class instead of a byte-budgeted floor
- Share a recycler pool between all size classes with the same chunk size
- Give the size classes from 16 KiB up the chunk size of their family

…ze class table

Motivation:

Which size classes share a recycler pool was computed by one nested loop in the static initialiser. An earlier
version of it merged only adjacent size classes with the same chunk size, and nothing noticed when a change of the
chunk geometry made equal chunk sizes non-adjacent: the pools silently stopped being shared.

Modification:

The tables are built by distinctChunkSizes(sizeClasses) and chunkPools(sizeClasses, chunkSizes), which take the
size class table as a parameter. One test checks that today's size classes share a pool exactly when their chunk
sizes are equal; another checks the same on 1000 seeded random tables, where equal chunk sizes are rarely adjacent.

Result:

The same tables (the recycler's bytecode is unchanged), and a geometry change that breaks pool sharing fails a test.

Motivation:

Four behaviours of a size-classed chunk had no test of their own: what it reports about its free segments
through every way a segment comes back, the deallocation of a freed allocator's chunk by a release that cannot take
the stripe lock, the segment a growing buffer leaves behind, and allocation racing releases from other threads.

Modification:

Add capacityQueriesFollowEveryWayASegmentComesBack, segmentReturnedExternallyAfterFreeMustStillDeallocateChunk,
aBufferThatOutgrowsItsSegmentGivesItBack and segmentsReleasedByOtherThreadsAreNeverHandedOutTwice, and share the
reflective freeHeap helper with the existing test that inlined it.

Result:

Each test fails when the code path it names is broken: the external-release deallocation skipped, an external
offer duplicated, the old segment kept on growth, hasFullCapacity ignoring the external list.