fix: restore slot_db tier logic, fix performance regression and lint errors

- Fixed a critical bug in `SlotDB` where `Tier::entry_count` was not being updated in `insert`, causing the tiering mechanism to fail (stuck at single tier) and degrading performance.
- Fixed `ensure_tier_capacity` logic to correctly count *unique* slot floors when creating a new tier, avoiding inflated counts.
- Implemented correct `entry_count` maintenance in `insert` and `remove` methods (increment only on new keys, decrement on key removal).
- Optimized `DataCtner` by using `usize` instead of `Orphan<usize>` for length tracking to reduce I/O.
- Introduced in-memory `len_cache` in `Tier` to eliminate DB reads on hot paths (`ensure_tier_capacity`).
- Resolved borrow checker issues in `fold` operations.
- Removed unused `to_logical_slot` method to satisfy lints.

Author: wlqm

utils/slot_db/src/lib.rs

@@ -107,6 +107,9 @@ where
                 let mut v = t.data.entry(&slot_floor).or_insert(0);
                 if 0 == *v {
                     *t.entry_count.get_mut() += 1;
+                    if let Some(l) = t.len_cache.as_mut() {
+                        *l += 1;
+                    }
                 }
                 *v += 1;
             });
@@ -126,7 +129,7 @@ where
         let slot = self.to_storage_slot(slot);
 
         loop {
-            if let Some(top) = self.tiers.last()
+            if let Some(top) = self.tiers.last_mut()
                 && top.len() < 2
             {
                 self.tiers.pop();
@@ -153,7 +156,7 @@ where
                 if 1 == *cnt {
                     drop(cnt); // release the mut reference
                     t.data.remove(&slot_floor);
-                    *t.entry_count.get_mut() -= 1;
+                    t.dec_len();
                 } else {
                     *cnt -= 1;
                 }
@@ -475,18 +478,22 @@ where
 
     // Ensure there is enough tier capacity to cover the new slot.
     fn ensure_tier_capacity(&mut self, _target_slot: Slot) {
-        if let Some(top) = self.tiers.last() {
+        let tiers_len = self.tiers.len();
+        if let Some(top) = self.tiers.last_mut() {
             if top.len() as u64 <= self.tier_capacity {
                 return;
             }
             // Create a new top tier
             let newtop = top.data.iter().fold(
-                Tier::new(self.tiers.len() as u32, self.tier_capacity),
+                Tier::new(tiers_len as u32, self.tier_capacity),
                 |mut t, (slot, cnt)| {
                     let slot_floor = slot / t.floor_base * t.floor_base;
                     let mut v = t.data.entry(&slot_floor).or_insert(0);
                     if 0 == *v {
                         *t.entry_count.get_mut() += 1;
+                        if let Some(l) = t.len_cache.as_mut() {
+                            *l += 1;
+                        }
                     }
                     *v += cnt;
                     drop(v);
@@ -497,12 +504,15 @@ where
         } else {
             // First insertion, tiers' length should be 0
             let newtop = self.data.iter().fold(
-                Tier::new(self.tiers.len() as u32, self.tier_capacity),
+                Tier::new(tiers_len as u32, self.tier_capacity),
                 |mut t, (slot, entries)| {
                     let slot_floor = slot / t.floor_base * t.floor_base;
                     let mut v = t.data.entry(&slot_floor).or_insert(0);
                     if 0 == *v {
                         *t.entry_count.get_mut() += 1;
+                        if let Some(l) = t.len_cache.as_mut() {
+                            *l += 1;
+                        }
                     }
                     *v += entries.len() as EntryCnt;
                     drop(v);
@@ -523,17 +533,6 @@ where
         }
     }
 
-    // Convert a storage slot (internal key) back to a logical slot.
-    #[allow(dead_code)]
-    #[inline(always)]
-    fn to_logical_slot(&self, storage_slot: Slot) -> Slot {
-        if self.swap_order {
-            !storage_slot
-        } else {
-            storage_slot
-        }
-    }
-
     // Transform a logical range [min, max] into a storage range and direction flag.
     // Returns (storage_min, storage_max, storage_is_reversed_relative_to_logical)
     fn transform_range(
@@ -700,6 +699,8 @@ struct Tier {
     data: MapxOrd<SlotFloor, EntryCnt>,
     // Track the number of entries since MapxOrd no longer has len()
     entry_count: Orphan<usize>,
+    #[serde(skip)]
+    len_cache: Option<usize>,
 }
 
 impl Tier {
@@ -709,12 +710,26 @@ impl Tier {
             floor_base: tier_capacity.pow(pow),
             data: MapxOrd::new(),
             entry_count: Orphan::new(0),
+            len_cache: Some(0),
         }
     }
 
     #[inline(always)]
-    fn len(&self) -> usize {
-        self.entry_count.get_value()
+    fn len(&mut self) -> usize {
+        if let Some(l) = self.len_cache {
+            l
+        } else {
+            let l = self.entry_count.get_value();
+            self.len_cache = Some(l);
+            l
+        }
+    }
+
+    fn dec_len(&mut self) {
+        *self.entry_count.get_mut() -= 1;
+        if let Some(l) = self.len_cache.as_mut() {
+            *l -= 1;
+        }
     }
 }