The util/uaerospike.Client wraps the aerospike-client-go client with an
in-process semaphore sized at the policy's ConnectionQueueSize (or
DefaultConnectionQueueSize = 128 when no policy supplies one). Every
Put / PutBins / Delete / Get / Operate / BatchOperate call must acquire
a slot before proceeding; release on return.

Under heavy parallel workloads — especially batch-decorate paths that
fan out hundreds-to-thousands of concurrent goroutines into Aerospike —
the parked-goroutine memory tax dominates: each waiter pins its
NewKey, NewBatchRead, addAbstractedBins, and FieldNamesToStrings
allocations until a permit frees. On scaling-2 a single subtree-validator
pod parked ~21 K goroutines on acquirePermit, holding ~14 GB of closure
state, and OOM-killed at the 180 GiB memory limit.

This change adds an option-pattern knob so the in-process throttle can
be tuned (or removed) without rebuilding the binary:

  aerospike_semaphore_multiplier (float64, default 1.0)
    0   disables the semaphore entirely. All acquirePermit /
        releasePermit calls become no-ops; only the underlying
        aerospike client's own connection pool governs concurrency.
        Use when the caller already bounds concurrency upstream
        (e.g. via a batcher) and the parking overhead is undesirable.
    1.0 preserves prior behavior (one semaphore slot per
        ConnectionQueueSize-derived permit).
    <1  over-restricts — useful when sharing the aerospike server
        with other clients.
    >1  raises the cap — only safe when the deployment has been
        verified to handle more concurrent operations than the
        default queue size implies.

Negative values are treated as 0 (semaphore disabled).

Implementation:
  * util/uaerospike.WithSemaphoreMultiplier(float64) — a ClientOption
    applied via the new variadic-options NewClient(host, port, opts...)
    and the slice-args NewClientWithPolicyAndHostOpts(policy, hosts, opts).
    The existing NewClientWithPolicyAndHost(policy, hosts...) signature
    is preserved verbatim — it now forwards to the opts-aware variant
    with a nil options slice.
  * buildConnSemaphore(queueSize, multiplier) computes
    max(1, round(queueSize * multiplier)) or returns nil when the
    multiplier <= 0. acquirePermit / releasePermit no-op when the
    underlying channel is nil.
  * settings/aerospike_settings.go adds the float64 SemaphoreMultiplier
    field with longdesc covering all four value bands.
  * util/aerospike.go threads the setting through at the production
    NewClientWithPolicyAndHostOpts call site.

Unit tests in util/uaerospike/client_test.go cover:
  * buildConnSemaphore capacity math across default / disabled /
    fractional / huge / tiny-positive-clamps-to-1 multipliers.
  * acquirePermit / releasePermit no-op behavior on a Client whose
    semaphore was disabled (1000 sequential cycles).
  * newClientConfig option application + nil-option tolerance.

… size, clamp NaN/Inf

Three correctness fixes from review of the original PR:

1. settings/settings.go was missing the imperative loader entry for
   aerospike_semaphore_multiplier, so the struct-tag default of "1.0"
   never took effect — settings.NewSettings() returned 0.0 and every
   deployment without an explicit override silently ran with the
   in-process semaphore disabled. Add the getFloat64 call so the
   documented 1.0 default actually applies.

2. Client.GetConnectionQueueSize returned cap(nil) = 0 when the
   semaphore was deliberately disabled, which made the pruner's
   recommendedMax = 0 × threshold and collapsed chunkGroupLimit to 1.
   Store the resolved underlying connection-queue size on Client and
   report it when the semaphore is nil so external pool-capacity
   heuristics survive an opt-out.

3. buildConnSemaphore did not guard NaN/+Inf or runaway scaled values
   before make(chan, ...). NaN now disables the semaphore (treated as
   garbage input); +Inf and any scaled value above maxSemaphoreCapacity
   (1<<20) are clamped so a typo like 1.0e10 cannot allocate a multi-GB
   channel.

Adds a settings.NewSettings() regression test that asserts the runtime
default is 1.0 — the existing tests bypass the broken seam by calling
newClientConfig / buildConnSemaphore directly. Also extends
TestBuildConnSemaphore with NaN/+Inf/clamp cases and adds an explicit
fallback test for GetConnectionQueueSize.

buildOOBFixture and buildInRangeFixture created their SyncedMap with
limit=2 and then inserted exactly 2 entries. The _NilParentTx tests
subsequently Set on an existing key; once len == limit, go-tx-map's
setUnlocked evicts a random item from the map before writing — which
~50% of the time drops the child the SUT is about to look up, leaving
the test failing with "tx <hash> not found in txMap". Reproduced
locally with -count=20 under -race.

Use an unbounded SyncedMap in the fixtures (the production path sizes
by block tx count, not 2) and leave a comment explaining the eviction
trap so future fixtures don't fall into the same hole.

Duplicates the fix in PR #931 so this PR's CI is unblocked
independently; will fold into theirs if #931 lands first.

(Amended to force a fresh CI trigger — the prior push at 13:09 didn't
fire a pull_request event.)

…ader

# Conflicts:
#	services/legacy/netsync/handle_block_test.go