feat(bo): batch, asynchronous, constrained and integer Bayesian optimization, completing batch B

[tachsin]

The second part of batch B in the optimization plan, after #382: Bayesian optimization in batches, asynchronously, with constraints, and on integer genes.

Batches: .batch(q) with .fantasy(bo::Fantasy::KrigingBeliever), the default, or ConstantLiar(Lie::Min | Mean | Max) (Ginsbourger, Le Riche and Carraro 2010, Algorithms 1 and 2, checked).

• Each point of a batch is chosen after the earlier ones are added with a fantasized value, through GaussianProcess::with_points. Hyperparameters are not refit within a batch.
• With Engine::parallel(true), a batch is evaluated in parallel, with the same bits on any number of threads.
• batch(1) reproduces single-point runs bit for bit.
• The believer is the default on evidence. With batches of 4 over 20 seeds, it ties the lowest lie and beats the mean and highest lies. Under AsyncEngine it reached Hartmann 3 in 5 of 5 runs, against 2 of 5 for the lowest lie.

Asynchronous: Bo implements Incremental, so AsyncEngine proposes a point while others are pending, with the pending points fantasized. A checkpoint holds them, and a resumed run matches an uninterrupted one. Incremental gains defaulted prepare, wants and receive_evaluation, and AsyncEngine evaluates the wanted extras.

Constraints (Gardner et al. 2014, checked):

• Constraint values come from Constrained or a problem's own. Each constraint gets its own GP.
• EI is multiplied by the probability of feasibility, and log-EI adds its logarithm. Before any feasible point exists, that probability alone is maximized.
• UCB with constraints is an error.

Integer genes: Bo<R: bo::Space = Real>, with Space implemented for Real and Integer.

• The model sees lattice points only (Garrido-Merchán and Hernández-Lobato 2020, eq. 7).
• The acquisition is maximized on the lattice: exhaustively when the lattice is small, otherwise by raw samples and a ±1 hill climb.
• A fully evaluated lattice ends the run as Converged.

In Python and the CLI:

• Python: gx.Bo(..., batch=, fantasy=), run(f, constraints=m), and integer genomes.
• CLI: batch, fantasy, asynchronous = true, integer genomes, and constraint values from fitness programs.

Examples (Rust and Python identical, except the asynchronous one):

• bo_hartmann6: batches of 4 come within 1e-4 of the global minimum in 15 rounds (74 evaluations), against 36 rounds one point at a time. The global minimum depends on the seed: batches reach it in 13 of 20 seeds and single points in 12 of 20, the rest stopping at the local minimum −3.2032. The README says so.
• bo_constrained: Gramacy et al.'s toy problem. It comes within 1e-5 of f* = 0.5997880520 (checked with mpmath and a grid scan) in 21 evaluations, and every one of 20 seeds within 39. Given only the total violation, the same search ends 0.34 above.
• bo_asynchronous (Rust only): Hartmann 3 to 1e-4 with 4 workers and evaluations of 10-50 ms, in about 0.4 s, against 0.8 s for batches of 4. Its timings are masked in CI.

Tests:

• Batch and fantasy behaviour; the same bits on 1, 2 and 8 threads.
• Async with one worker reproducible.
• Constrained BO on the Gramacy problem and CEC 2006 G24, and the probability of feasibility's gradients.
• Integer BO.
• Checkpoints, including pending points.
• portable_runs entries and Python tests.