Relax is_nchoosek_pruning_applicable() to allow NChooseK features that
also participate in linear equality/inequality constraints (only block
for nonlinear/product/interpoint overlap). When linear overlap exists,
pruning variants use QP projection (LinearProjection) to find a feasible
warm-start with x_k=0, then local optimize_acqf to find the best
achievable AF value — giving accurate greedy decisions. The simple
zeroing path is preserved when no linear overlap exists.

- Relax is_nchoosek_pruning_applicable: linear overlap now allowed
- Add Domain.has_nchoosek_linear_overlap() to select pruning path
- Add QP + local optimize_acqf variant construction in botorch.py
- Add _build_pruning_domain to create modified domain for QP projection
- Add end-to-end test with NChooseK + mixture constraint (sum=1)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Phase 1 of the BONSAI pruning refactor: a self-contained, tensor-native
implementation of greedy NChooseK pruning that can later be wired into
BotorchOptimizer. Strategy-side code in BotorchStrategy is untouched and
will be migrated in Phase 2.

The module extends today's pruning beyond what BotorchStrategy currently
does:

- active variant for semi-continuous features (allow_zero=True with
  lb > 0): each fractional value is resolved either to zero or snapped
  into [lb, ub] via QP projection + optional local optimize_acqf
- multiple NChooseK constraints with per-constraint active counts and
  conjunction-style termination
- per-constraint min_count guard with none_also_valid exception, raising
  PruningInfeasibleError when the action set empties before all
  max_count constraints are satisfied
- caller-supplied fixed_features flow through to both QP projection and
  local re-opt, and are excluded from the action set so the loop never
  proposes to move them
- two hyperparameters: per_step_local_reopt (refine each variant via
  optimize_acqf), final_local_reopt (single end-of-loop clean-up solve)
- pinned-zero-indices machinery prevents the linear-redistribution from
  resurrecting previously-zeroed features across iterations

The cvxpy LinearProjection round-trip is replaced by BoTorch's native
project_to_feasible_space_via_slsqp, eliminating the numpy boundary in
the pruning loop and dropping the bespoke pruning-domain construction.

The full conceptual write-up lives in docs/pruning.md, with a worked
4-feature example and a comparison to the published BONSAI algorithm.

Test coverage in tests/bofire/strategies/test_nchoosek_pruning.py (45
unit tests): pure helpers (classification, fulfilment, counts, guard,
eligibility), variant construction (zero/active, no-overlap, mixture eq,
inequality-only, infeasibility), end-to-end pruning (single/multiple
NChooseK, semi-continuous, min_count guard, hyperparameter smoke tests,
fixed-features regression, q=0, tie-break, QP-failure fallback).

Structural cleanup of the pruning module — no behavior change, all
118 + 6 new tests pass:

- Add Action, ActionKind, PruningContext, PruningState dataclasses;
  replace anonymous tuples and stringly-typed action kinds.
- Unify _build_zero_variant / _build_active_variant /
  _build_activate_variant behind a single _build_variant(kind, ...)
  dispatcher; keep the three legacy wrappers for backward compat.
- Extract _collect_actions(state, ctx, fixed_keys) -> List[Action]
  to fold the three duplicated action-collection for-loops.
- Extract _prune_single_candidate(x_i, X_prefix, ctx, fixed_keys)
  out of prune_nchoosek; the public function is now a 30-line
  outer loop and the inner per-candidate logic is a self-contained
  primitive that beam-search and B&B can build on directly.
- Replace the manual argmin loop with min(..., key=...).
- Drop the # noqa: C901 escape on prune_nchoosek.
- Add 5 dataclass smoke tests + 1 q>1 prefix-conditioning regression
  test (the existing test_q2 only checked that both candidates ran,
  not that the second conditioned on the first's pruned form).

Pairs missing tests with the categorical/discrete pinning fix already
landed in 8906fa0. The new TestPinnedColumns class covers the
per-row resolution semantics (q=1 and q=2 with row-varying values),
both reopt-path coverage, and the categorical one-hot integration
test. Also migrates three legacy tests from fixed_features= to the
new pinned_columns= API.

Adds two TODO comments in _build_variant referencing facebook/Ax#5180:
- Skip SLSQP projection when the action dim is not in any linear
  constraint (perf win).
- Post-projection feasibility safety net (defensive).

Both are documented but deferred -- small wins on a non-bottleneck
path, revisit if profiling shows _build_variant is hot.

is_pruning_applicable only blocks pruning when NChooseK features
*overlap* with an InterpointConstraint, NonlinearConstraint, or
ProductConstraint. If those constraints exist on non-NChooseK
features, the gate passes and pruning runs -- but the QP projection
inside prune_nchoosek only sees Linear{Equality,Inequality}
constraints (filtered by get_linear_constraints), so features
participating in the other constraint types may drift during
projection and silently break those constraints.

Fix: in BotorchOptimizer._prune_if_applicable, extend pinned_columns
to include every feature participating in those three unhandled
constraint types. The candidate carries values satisfying these
constraints at row entry (upstream optimizer respected them); pinning
preserves them by inertia.

Same defensive principle as the categorical/discrete fix in 8906fa0 --
anything pruning's QP cannot reason about, freeze at the per-row
value.

Adds a regression test asserting an InterpointEqualityConstraint
feature survives pruning unchanged.

BotorchOptimizer.validate_domain already rejected LSR-BO combined
with non-LinearConstraint via the existing
'LSR-BO only supported for linear constraints' check; since
NChooseKConstraint is not a LinearConstraint subclass, that branch
already caught NChooseK + LSR-BO at strategy-construction time.
The only remaining case the validator missed was semi-continuous
features (`allow_zero=True` with `bounds[0] > 0`) -- an input
property, not a constraint.

Extend validate_local_search_config to also reject semi-continuous
features. With both cases now caught at data-model validation, the
runtime NotImplementedError in BotorchOptimizer._optimize becomes
redundant and is removed.

User benefit: fail at strategy construction with a ValueError, not
at runtime in `ask()` with a NotImplementedError. Earlier signal,
discoverable in the data model.

Adds three validator tests: NChooseK + LSR-BO rejection (regression
on the existing branch), semi-continuous + LSR-BO rejection (new
branch), and plain-continuous + LSR-BO passes (the supported case).

The semi-continuous enumeration in get_number_of_categorical_combinations
and get_categorical_combinations was checking `allow_zero and not
is_fixed()` -- this works in practice because the ContinuousInput
validator forbids `allow_zero=True with bounds[0]==0`, but the intent is
clearer when expressed via the is_semicontinuous property.

Same defensive principle as the pinning policy: a feature is
"conditional" (gets the 2x active/inactive factor in the combination
count) only when its feasible region is the disconnected union
`{0} ∪ [lb, ub]` -- i.e., when `is_semicontinuous` is True. The
explicit `bounds[0] > 0` check inside the property guards against any
future validator relaxation that would allow allow_zero with zero
lower bound.