Implement keep-if-fits buffer reuse to reduce heap fragmentation

Replace per-page buffer free+realloc pattern with capacity tracking that only reallocates when needed size exceeds current capacity. This prevents heap fragmentation from non-coalescing holes that occurred when each page's freed block rarely fit the next page's allocation. After a few page turns, capacities converge on the book's maximum and page turns stop touching the allocator entirely.

src/activities/reader/EpubReaderActivity.cpp

@@ -257,6 +257,27 @@ void EpubReaderActivity::openReaderMenu() {
                          });
 }
 
+bool EpubReaderActivity::buildTickHeapGate() {
+  const size_t freeHeap = ESP.getFreeHeap();
+  const size_t maxBlock = ESP.getMaxAllocHeap();
+  if (freeHeap >= BACKGROUND_BUILD_MIN_FREE_HEAP && maxBlock >= BACKGROUND_BUILD_MIN_MAX_ALLOC) {
+    return true;
+  }
+  // Below the floors. If the BLE stack is what's squeezing the heap, shed it — the
+  // established policy on this branch is that builds and resident BLE don't coexist,
+  // and this was the one build path without that protection (field crash: a tick's
+  // parse allocation aborted at maxAlloc ~11 KB with BLE resident). The lifecycle's
+  // build-pending deferral keeps BLE down until the window is caught up, then
+  // restarts it behind the start floor. Without BLE resident, just wait: page-turn
+  // transients free up between turns and the tick retries every loop pass.
+  if (BleHid.isRunning()) {
+    LOG_INF("ERS", "Background build needs heap (free=%u maxAlloc=%u); freeing BLE RAM", (unsigned)freeHeap,
+            (unsigned)maxBlock);
+    bleinput::stop();
+  }
+  return false;
+}
+
 void EpubReaderActivity::loop() {
   if (!epub) {
     // Should never happen
@@ -269,12 +290,10 @@ void EpubReaderActivity::loop() {
   // RenderLock and locked out page turns. The build follows the reader instead, and instant
   // reopen comes from suspendBuild() persisting the laid-out pages as a partial on exit.
   // Skip while the render mutex is busy so we never delay a pending render; re-check
-  // isBuilding() under the lock since render() may have just finished it. Also skip
-  // while free heap is below the floor — the tick is deferrable, and parsing into a
-  // starved heap abort()s (see BACKGROUND_BUILD_MIN_FREE_HEAP).
+  // isBuilding() under the lock since render() may have just finished it.
   if (section && section->isBuilding() && !RenderLock::peek() &&
       static_cast<int>(section->pageCount) < section->currentPage + BUILD_WINDOW_AHEAD &&
-      ESP.getFreeHeap() >= BACKGROUND_BUILD_MIN_FREE_HEAP) {
+      buildTickHeapGate()) {
     RenderLock lock;
     // Re-check under the lock: render() (which also holds the RenderLock) may have finalized the
     // build between the outer isBuilding() check and acquiring the lock here, in which case
@@ -1273,6 +1292,10 @@ void EpubReaderActivity::render(RenderLock&& lock) {
     const auto start = millis();
     renderContents(std::move(p), orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft);
     LOG_DBG("ERS", "Rendered page in %dms", millis() - start);
+    // Fragmentation tracker: free vs largest block after every page. A falling
+    // maxAlloc/free ratio across pages points at whichever allocation pattern the
+    // preceding lines show (mini rebuilds, kern reloads, BLE churn).
+    LOG_DBG("MEM", "post-render: free=%u maxAlloc=%u", (unsigned)ESP.getFreeHeap(), (unsigned)ESP.getMaxAllocHeap());
   }
   saveProgress(currentSpineIndex, section->currentPage, section->estimatedTotalPages());
 

src/activities/reader/EpubReaderActivity.h

@@ -90,6 +90,17 @@ class EpubReaderActivity final : public Activity {
   // page-turn transients free up between turns and the build resumes; the render
   // path still builds the page it actually needs regardless of this floor.
   static constexpr size_t BACKGROUND_BUILD_MIN_FREE_HEAP = 32 * 1024;
+  // Fragmentation floor for the same gate: a tick passed the free-heap floor at
+  // 34.7 KB free but the largest block was ~11 KB, and a parse allocation inside the
+  // tick aborted anyway. Free heap says how much memory exists; maxAlloc says whether
+  // any single allocation can actually have it. 16 KB also keeps the advance-table
+  // batch path (16 KB scratch) viable during builds.
+  static constexpr size_t BACKGROUND_BUILD_MIN_MAX_ALLOC = 16 * 1024;
+  // Gate for a background build tick: true when the heap can take parse allocations.
+  // When BLE is what's squeezing the heap, sheds it (build-pending deferral in the
+  // lifecycle then holds restarts off until the window is caught up) instead of
+  // stalling the build forever below the floors.
+  bool buildTickHeapGate();
   // How many pages to keep laid out ahead of the reader for a still-building section. A page
   // turn is ~1s on e-ink and a page builds in ~30ms, so the reader can't out-click the builder
   // -- a tiny buffer is enough. The background build stops once the watermark is this far