fix: bound is_chart_bar_cluster's cubic cost on dense rect clusters

bar_family (used by is_chart_bar_cluster to distinguish bar charts
from cell-rect grids) iterates every rect as an anchor, rebuilds a
same-breadth "family" per anchor, then runs a nested any/filter over
that family plus a per-member full-page item scan — O(n^3) in the
cluster size in the worst case.

Profiling a real fixture (tests/fixtures/bits_pilani_feedback.pdf, a
dense feedback-form PDF) with samply + macOS `sample` showed
is_chart_bar_cluster consuming ~25% of total runtime, taking the file
from a documented ~200ms to 43s. A dense form/checkbox-grid page
clusters into hundreds of touching rects via cluster_rects, which is
exactly the case that makes the O(n^3) term dominate.

No real bar chart has hundreds of bars, so this adds
MAX_CHART_CLUSTER_RECTS (300, mirroring the existing MAX_CLUSTER_RECTS
pattern in this file) as an early bailout — clusters above that size
are treated as "not chart-like" instead of running the expensive
checks, which costs no detections against realistic PDFs. Also hoists
the redundant per-item `it.page == page` filter out of the
per-rect-checked closure since it's invariant for the whole call.

Verified: the fixture drops from 43s to 4.5s (~9.5x); full cargo test
suite (721 tests, including a new regression test asserting the
bailout fires in <100ms on an oversized cluster) passes unchanged.

Author: MADENIYOU

src/tables/detect_rects.rs

@@ -2006,17 +2006,37 @@ fn without_dominant_page_backgrounds(rects: &[(f32, f32, f32, f32)]) -> Vec<(f32
 /// holding at most a single numeric data label each. Bar charts drawn as
 /// filled rects otherwise read as cell rects and grid their axis labels
 /// into a phantom table. The mirrored check catches horizontal bar charts.
+/// Above this many rects in a cluster, the O(n²)-per-anchor cost inside
+/// `bar_family` below (itself run once per anchor, so effectively O(n³))
+/// becomes prohibitively expensive — a single dense form/checkbox-grid page
+/// (hundreds of touching rects clustered by `cluster_rects`) was measured
+/// taking tens of seconds here alone. No real bar chart has this many bars,
+/// so treating oversized clusters as "not chart-like" costs no detections
+/// against realistic PDFs while keeping worst-case cost bounded. Mirrors
+/// `MAX_CLUSTER_RECTS` above.
+const MAX_CHART_CLUSTER_RECTS: usize = 300;
+
 fn is_chart_bar_cluster(
     items: &[TextItem],
     group_rects: &[(f32, f32, f32, f32)],
     page: u32,
 ) -> bool {
+    if group_rects.len() > MAX_CHART_CLUSTER_RECTS {
+        return false;
+    }
+
+    // Hoisted out of `numeric_or_empty` so the `it.page == page` filter runs
+    // once per call to `is_chart_bar_cluster` instead of once per rect
+    // checked (every anchor's family can call `numeric_or_empty` for each of
+    // its members).
+    let page_items: Vec<&TextItem> = items.iter().filter(|it| it.page == page).collect();
+
     let numeric_or_empty = |(rx, ry, rw, rh): (f32, f32, f32, f32)| {
-        let inside: Vec<&TextItem> = items
+        let inside: Vec<&&TextItem> = page_items
             .iter()
             .filter(|it| {
                 let cx = it.x + it.width / 2.0;
-                it.page == page && cx >= rx && cx <= rx + rw && it.y >= ry && it.y <= ry + rh
+                cx >= rx && cx <= rx + rw && it.y >= ry && it.y <= ry + rh
             })
             .collect();
         // Any number of numeric data labels is chart-like; a single run of
@@ -4668,4 +4688,31 @@ mod tests {
             table.rows.len()
         );
     }
+
+    #[test]
+    fn is_chart_bar_cluster_bails_out_above_max_size() {
+        // A cluster larger than MAX_CHART_CLUSTER_RECTS must short-circuit
+        // to `false` instead of running bar_family's O(n^3) checks — this is
+        // the pathological case a dense form/checkbox-grid page hits (a real
+        // fixture measured 43s before this guard, ~4.5s after). Regression
+        // guard for the perf fix, independent of the exact heuristic result.
+        let oversized: Vec<(f32, f32, f32, f32)> = (0..MAX_CHART_CLUSTER_RECTS + 1)
+            .map(|i| (i as f32 * 12.0, 0.0, 10.0, 20.0))
+            .collect();
+        let items: Vec<TextItem> = Vec::new();
+
+        let start = std::time::Instant::now();
+        let result = is_chart_bar_cluster(&items, &oversized, 1);
+        let elapsed = start.elapsed();
+
+        assert!(
+            !result,
+            "oversized cluster must not be classified as a chart"
+        );
+        assert!(
+            elapsed.as_millis() < 100,
+            "oversized cluster should bail out immediately, took {:?}",
+            elapsed
+        );
+    }
 }