feat(local): aggregate blocked-on-dependency reporting by dependency (#131)

## Why

With cascade detection (#128) live, the latest `auto-apply-patches` run did exactly the right thing — **proposed nothing** (`No auto-proposable candidates`) because every failure is a dependency cascade, and it surfaced the ~30 root-cause dependencies to fix.

But the "Blocked on a dependency" list printed **one line per fingerprint group**, so the same dependency repeated (rstan ×4, lpsymphony ×4, salso ×2, BH ×2, GO.db ×2, RcppCWB ×2, …), burying the priority.

## What

Aggregate blocked packages across all groups **by the dependency they wait on**:

- Expose `blocked_map` (package → dependency) from `build_triage_report()`.
- Add `blocked_by_dependency()` — dedupes dependents (a package in two groups counts once) and ranks dependencies by how many distinct dependents they block.
- Proposer and tracker (log + issue) now print one line per dependency, sorted by impact. Replaces the per-group `blocked_summary`.

## Result (same data, aggregated)

```
Blocked on a dependency (3 dependencies block 6 dependents; fix the dependency, not each dependent):
  RcppParallel             3 dependent(s)
  rstan                    2 dependent(s)
  sf                       1 dependent(s)
```

So the real run becomes a crisp, ranked worklist: RcppParallel (894), sf (128), rstan (~96), Rfast (33), clarabel/DescTools (26), Rglpk (22), xgboost (18), …

## Verified

New test covers cross-group aggregation, dedup (a dependent in two groups counted once), the example cap, and ranking. 112 tests pass; hooks pass.

Reviewed-on: #131

local/tests/test-proposal-tracking-lib.R

@@ -146,20 +146,35 @@ test_that("unclassified_summary ranks unknown groups and caps output", {
   expect_identical(capped$dropped_groups, 1L)
 })
 
-test_that("blocked_summary lists each dependency and its dependent count", {
+test_that("blocked_by_dependency aggregates across groups, deduped and ranked", {
+  # RcppParallel dependents split across platforms/fingerprints -> separate
+  # groups, but one aggregated line; a dependent seen twice is counted once.
   failures <- data.frame(
-    name = c("ACEsimFit", "AovBay", "AdaptGauss"),
-    platform = "ubuntu-2604",
+    name = c("ACEsimFit", "AovBay", "AdaptGauss", "ACEsimFit", "loner"),
+    platform = c(
+      "ubuntu-2604",
+      "ubuntu-2604",
+      "alpine-324",
+      "alpine-324",
+      "ubuntu-2604"
+    ),
     arch = "amd64",
-    error_text = "Error: USE_TBB=Linux is not supported on this toolchain",
+    error_text = c(
+      rep("Error: USE_TBB=Linux is not supported on this toolchain", 4L),
+      "Failed to build source package rstan.\nfatal error: tbb/tbb_stddef.h"
+    ),
     stringsAsFactors = FALSE
   )
   report <- build_triage_report(failures, registered_pkgs = character(0L))
-  b <- blocked_summary(report, max_pkgs = 2L)
-  expect_length(b, 1L)
-  expect_identical(b[[1L]]$blocked_on, "RcppParallel")
-  expect_identical(b[[1L]]$n_packages, 3L)
-  expect_true(b[[1L]]$packages_truncated)
+  agg <- blocked_by_dependency(report, max_pkgs = 2L)
+  deps <- vapply(agg, function(b) b$dependency, character(1L))
+  expect_true("RcppParallel" %in% deps && "rstan" %in% deps)
+  rcpp <- Filter(function(b) b$dependency == "RcppParallel", agg)[[1L]]
+  # ACEsimFit appears in two groups -> counted once (3 distinct dependents).
+  expect_identical(rcpp$n_packages, 3L)
+  expect_true(rcpp$packages_truncated) # capped at max_pkgs = 2
+  # Ranked by dependent count: RcppParallel (3) before rstan (1).
+  expect_identical(deps[[1L]], "RcppParallel")
 })
 
 test_that("entry_applies_to_os matches codename, family, and wildcard", {