M5.6a: memory report (library.memory, ui.inspect memory) and opt-in DHAT heap profile

Per-cache bytes: decoded thumbnail/preview/full sources, rendered previews,
GPU device buffers (allocated/pooled/retired), loupe stage caches (CPU and
GPU) and textures. lightcraft-cli --features dhat-heap adds live/peak heap and
writes dhat-heap.json.

Baseline (14 raws, loupe, 12 steps): peak RSS 1.9-2.3 GB, footprint 2.5-2.6 GB;
heap peak 634 MB after import (probes decode every raw), 930 MB during grid
thumbnails (parallel decodes); GPU free pool grows to 2 GB (exact-size reuse).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/gpu/src/render.rs

@@ -82,6 +82,41 @@ impl GpuStages {
         self.lock().len()
     }
 
+    /// Device bytes held (each buffer counted once).
+    pub fn bytes(&self) -> usize {
+        let mut seen: Vec<*const Buf> = Vec::new();
+        let mut total = 0;
+        let mut add = |b: &Arc<Buf>| {
+            let p = Arc::as_ptr(b);
+            if !seen.contains(&p) {
+                seen.push(p);
+                total += b.len * 4;
+            }
+        };
+        for e in self.lock().iter() {
+            add(&e.sampled);
+            if let Some((_, b)) = &e.lin {
+                add(b);
+            }
+            let p = &e.planes;
+            p.log_l.iter().for_each(&mut add);
+            p.base.iter().for_each(|(_, b)| add(b));
+            p.clarity.iter().for_each(|(_, b)| add(b));
+            p.texture.iter().for_each(|(_, b)| add(b));
+            p.dark.iter().for_each(|(_, b, _)| add(b));
+        }
+        if let Some((_, b)) = &*self.source.lock().unwrap_or_else(|e| e.into_inner()) {
+            add(b);
+        }
+        total
+    }
+
+    /// Drop everything (e.g. when memory is needed).
+    pub fn clear(&self) {
+        self.lock().clear();
+        *self.source.lock().unwrap_or_else(|e| e.into_inner()) = None;
+    }
+
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }