feat: CBC-style threaded branch & bound (-threads N)

Opportunistic parallel tree search as CBC's: N workers over a shared
node heap, incumbent and pseudocost arrays, each worker on its own
problem copy + LP (reduced-cost fixing mutates column bounds, and a
factor's solve scratch belongs to the LP that built it). Nodes crossing
the shared heap carry a Portable() basis — status/values only, no
factorization — and the receiving worker refactorizes, the same
contract as CBC handing CoinWarmStartBasis between threads. Each
worker re-applies reduced-cost fixing when another worker tightens the
incumbent. In-tree cut generation stays serial-only (local cut rows
would be dangling row indices in other workers' problems).

Serial (Threads<=1) runs the same treeSearch code path with
uncontended locks: 018/020/021 keep bit-identical nodes, pivots and
objectives vs main (7/31746, 774/182619, 3/62278).

Benchmarks: 90x30 multi-knapsack 1.58s -> 0.19s at 8 threads (8.4x,
same optimum); 020 10.4s -> 7.8s at 4 threads (1.33x) with the same
node-inflation pattern real CBC shows there (271 -> 832 nodes, 1.25x).
Race detector clean over unit tests and a full threaded 020 solve.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: andig

README.md

@@ -77,6 +77,14 @@ It fails on any failure not listed in `testdata/pulp_known_failures.txt`.
   node bound propagation, reduced-cost fixing per incumbent, SOS1/2, one
   restart inheriting cuts/fixings/probes; periodic in-tree rounds of the
   globally-valid cut families with cold-restarted open nodes.
+- **Threads** (`-threads N`, CBC's opportunistic parallel B&B): N workers over
+  a shared node heap/incumbent/pseudocosts, each with its own problem copy and
+  LP; warm bases cross threads factorization-free (as CBC's CoinWarmStartBasis)
+  and the receiver refactorizes. Serial (`N<=1`) runs the same code path
+  bit-identically. Tree-heavy instances scale near-linearly (8.4x at 8
+  threads on a 90x30 multi-knapsack); dive-dominated trees gain what CBC
+  gains (020: 1.3x at 4 threads vs CBC's 1.25x). In-tree cuts stay
+  serial-only.
 - **Branching**: CBC reliability branching (pseudocosts, `numberBeforeTrust`=10,
   capped strong-branch probes, `maxStrong`=5, CBC score) + strong-branch fixing.
 - **Heuristics** (reduced-sub-problem first, as CBC's mini branch and bound):

cmd/cbc/main.go

@@ -22,7 +22,7 @@ import (
 // section: cuts/presolve/threads only affect performance, not the answer.
 var valueOnlyFlags = map[string]bool{
 	"presolve": true, "gomory": true, "knapsack": true, "probing": true,
-	"cuts": true, "threads": true, "strong": true, "timemode": true,
+	"cuts": true, "strong": true, "timemode": true,
 	"printingoptions": true,
 }
 
@@ -56,6 +56,7 @@ func run(args []string) error {
 	var solutionFile, mipsFile string
 	maximize := false
 	lpOnly := false
+	threads := 0
 	// GapAbs 1e-5 = CBC's default cutoff increment (CbcCutoffIncrement):
 	// nodes within 1e-5 of the incumbent are pruned, as real CBC does
 	limits := mip.Limits{GapRel: 1e-9, GapAbs: 1e-5}
@@ -91,6 +92,10 @@ func run(args []string) error {
 			if v, err := strconv.ParseFloat(next(), 64); err == nil {
 				limits.GapAbs = v
 			}
+		case "threads":
+			if v, err := strconv.Atoi(next()); err == nil {
+				threads = v
+			}
 		case "maxnodes":
 			if v, err := strconv.Atoi(next()); err == nil {
 				limits.MaxNodes = v
@@ -138,6 +143,7 @@ func run(args []string) error {
 	} else {
 		model := mip.New(p)
 		model.Limits = limits
+		model.Threads = threads
 		res = model.Solve()
 	}