perf(patchwork): TBB parallel_for in classic Patchwork (+1.73× Hz); Patchwork++ stays sequential after benchmark

[LimHyungTae]

What

Part B of the TBB / common-library refactor agreed in #89 (Part A is #94). Adds tbb::parallel_for to the classic Patchwork main loop and benchmarks Patchwork++ under the same pattern. Patchwork++ does not become parallel — measurement showed it hurts at every thread count.

Headline numbers (KITTI seq 00, i7-12700, 24 logical cores)

Configuration	Median ms / frame	Median Hz
Classic Patchwork single-thread (taskset -c 0)	8.31	120.4
Classic Patchwork parallel (this PR)	4.81	207.8 (+1.73×)
Patchwork++ single-thread	9.02	110.9
Patchwork++ — TBB at 2 threads (rejected)	10.73	93.2
Patchwork++ — TBB at 8 threads (rejected)	11.05	90.5
Patchwork++ — TBB at 24 threads (rejected)	14.55	68.7

Per-patch work in Patchwork++ is too small (~14 µs avg) and dominated by short-lived std::vector / Eigen::Matrix allocations inside R-VPF + R-GPF. Concurrent malloc serialises on the heap allocator, and TBB scheduler overhead exceeds the parallelisation benefit at every thread count. Single-threaded Patchwork++ already runs at ~2× the paper's reported 55 Hz on i7-7700K, so there is no real-time motivation to parallelise. The decision is documented in a long-form code comment in estimateGround.

Numerical equivalence — passes

KITTI 00-10 full sweep (23,201 frames), Patchwork++ paper protocol:

Configuration	Master	This PR	ΔF1
--method patchwork × pp proto	96.0172	96.0172	0 (byte-identical)
--method patchworkpp × pp proto	96.2918	96.2919	+0.0001 (float noise)

Both well under the ±0.05 macro budget set in the refactor plan.

Build changes

• cpp/CMakeLists.txt: find_package(TBB CONFIG REQUIRED) (falls back to MODULE), with an error message listing the install command for Ubuntu / macOS / Windows if TBB is missing.
• cpp/patchwork/CMakeLists.txt: links TBB::tbb.
• cpp/patchworkpp/CMakeLists.txt: unchanged (no TBB use).
• The CI workflows already install libtbb-dev on Ubuntu via apt; macOS / Windows wheel builds should pick TBB up automatically — I'll watch the CI matrix here.

Adds

• python/examples/bench_hz.py — small per-frame timing harness that reports median / mean / p95 / p99 ms and Hz from getTimeTaken(). Useful for future perf work.

Code changes summary

• cpp/patchwork/src/patchwork.cpp: replace the triple-nested for loop with a flat tbb::parallel_for over a pre-built patch index list; serial reduction phase walks the outcome buffer in deterministic order.
• cpp/patchwork/include/patchwork/patchwork.h: extract_initial_seeds and perform_regionwise_segmentation are now const (they were already pure functions of their arguments + params_; needed so the TBB worker can call them).
• cpp/patchworkpp/src/patchworkpp.cpp: unchanged behaviour, but the main loop now has the "why we stayed sequential" comment.
• Various small const / namespace tidying in the patchworkpp headers from the TBB prototyping that's harmless to keep.

Test plan

• pip install -v ./python/ builds.
• Smoke test seq 00 50 frames matches v1.3.1 baseline exactly.
• Equivalence sweep KITTI 00-10 (table above).
• Hz benchmark (table above), scaling test on Patchwork++ (1/2/4/8/16/24 threads, all in commit message).
• pre-commit run clean.

Follow-up

After this lands, plan is to cut v1.4.0 (per the refactor plan agreed earlier):

• v1.4.0 = Part A (refactor(common): extract shared PointXYZ / PCAFeature / plane-fit math (Part A of TBB work) #94) + Part B (this PR).
• Bump python/pyproject.toml + cpp/CMakeLists.txt to 1.4.0.
• CHANGELOG entry noting the +1.73× classic-Patchwork speedup and the no-op Patchwork++ result.
• Cut the GitHub Release to trigger PyPI publish.

Cross-refs: #89, #94.