perf(patchworkpp): kill per-patch heap traffic in R-VPF / R-GPF (+14.8% Hz)

[LimHyungTae]

Summary

Cuts per-frame Patchwork++ time on KITTI seq 00 from 10.26 ms → 8.94 ms (97.5 Hz → 111.9 Hz, +14.8% Hz, median of 3 runs, i7-12700). Patchwork classic is unaffected (already TBB-bound, see #95).

The win comes from killing short-lived heap allocations in the per-patch hot loop, exactly the bottleneck identified in #96.

What changed

High-impact (this is where the 14.8% comes from):

1. PatchWorkpp::estimate_plane: drop Eigen::MatrixX3f eigen_ground + centered + centered.adjoint() * centered. Replace with a single-pass scalar accumulation of mean and 9 cross-products, then build the 3×3 cov on the stack. No more per-call Eigen heap allocations.
2. PatchWorkpp::extract_piecewiseground: promote src_wo_verticals and src_tmp to reused instance scratch members. vector::clear() keeps capacity, so per-patch malloc pressure on the glibc heap (which was serializing the loop per Why Patchwork++ has no TBB parallelisation mode #96) drops away after the first few patches.
3. PatchWorkpp::estimateGround main loop: auto& zone instead of auto zone for ConcentricZoneModel_[zone_idx]. Avoids a deep-copy of the full 3-level nested vector per outer iteration. Safe: the in-place std::sort mutates patches that are read once and then flushed at the top of every estimateGround call.

Lower-impact, kept for cleanliness:

4. JacobiSVD<Matrix3f> → SelfAdjointEigenSolver::computeDirect for the 3×3 PSD covariance in both cpp/common/src/plane_fit.cpp and the in-place PatchWorkpp::estimate_plane. Closed-form, no Jacobi iterations. singular_values_ is repacked descending so every consumer (linearity/planarity in common, flatness_thr index (2) in patchwork classic, ground_flatness=minCoeff() and line_variable=sv(0)/sv(1) in patchwork++) keeps the same convention bit-for-bit.
5. const& on addCloud's add parameter, RevertCandidate loop vars, and the temporal_ground_revert / calc_point_to_plane_d / calc_mean_stdev signatures.

Benchmarks

KITTI seq 00, 2900 timed frames, median of 3 runs:

Stage	patchwork++	patchwork (classic)
baseline (JacobiSVD + per-call allocs)	10.26 ms / 97.5 Hz	4.26 ms / 234.7 Hz
eigh only	9.94 ms / 100.6 Hz (+3.2%)	4.30 ms / 232.8 Hz (noise)
eigh + alloc-free	8.94 ms / 111.9 Hz (+14.8%)	4.29 ms / 232.9 Hz (noise)

Patchwork classic is unchanged on the perf side: TBB parallel_for already amortizes allocations across 24 cores and SVD is sub-µs/patch.

Numerical equivalence

Full KITTI seq 00 (4541 frames):

method (protocol)	before	after	Δ
patchwork (pw)	P 92.34, R 94.64, F1 93.41	P 92.34, R 94.64, F1 93.41	0.00
patchwork++ (pp)	P 94.88, R 98.47, F1 96.62	P 94.89, R 98.48, F1 96.63	+0.01 F1

Algebraic identity of JacobiSVD vs eigh verified on 500 real KITTI patch covariances: normal_ (up to sign), singular_values_, linearity_, planarity_, ground_flatness, and line_variable all match to FP precision. All deltas well within the ±0.05 macro / ±0.10 per-seq budget.

Refs #96.

Test plan

• pip install -v ./python/ builds clean on Linux (gcc 13)
• evaluate_semantickitti.py --method patchworkpp --eval_protocol patchworkpp --seqs 00 matches baseline within ±0.05 F1
• evaluate_semantickitti.py --method patchwork --eval_protocol patchwork --seqs 00 bit-identical to baseline
• bench_hz.py --method patchworkpp --seq 00: +14.8% Hz, stable across 3 runs
• bench_hz.py --method patchwork --seq 00: within run-to-run noise of baseline
• CI matrix (Linux/macOS/Windows wheels + ros2_node + cpp_api) green