perf(l1): rebuild_bloom - insert instead of merge (#5266)

Merging layer filters is very costly due to the cost of iterating the
elements of a filter. Inserting has proven to be cheaper for the size of
the filter we're using and the amount of elements we are holding. Some
measurements:

- Early hoodi imports went from 8 blocks per second to about 80 (10x).
- Synced hoodi rebuild time went from ~166ms to ~27ms, (about a 6x). 

The PR also simplifies the rebuild code and avoids using rayon entirely.

---------

Co-authored-by: Javier Rodríguez Chatruc <49622509+jrchatruc@users.noreply.github.com>
Co-authored-by: Javier Chatruc <jrchatruc@gmail.com>

Author: Arkenan

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### 2025-11-11
 
+- Insert instead of merge for bloom rebuilds [#5223](https://github.com/lambdaclass/ethrex/pull/5223)
 - Replace sha3 keccak to an assembly version using ffi [#5247](https://github.com/lambdaclass/ethrex/pull/5247)
 - Fix `FlatKeyValue` generation on fullsync mode [#5274](https://github.com/lambdaclass/ethrex/pull/5274)
 

crates/storage/trie_db/layering.rs

@@ -1,5 +1,4 @@
 use ethrex_common::H256;
-use rayon::iter::{ParallelBridge, ParallelIterator};
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
 
@@ -133,45 +132,29 @@ impl TrieLayerCache {
         self.layers.insert(state_root, Arc::new(entry));
     }
 
-    /// Rebuilds the global bloom filter accruing all current existing layers.
+    /// Rebuilds the global bloom filter by inserting all keys from all layers.
     pub fn rebuild_bloom(&mut self) {
-        let mut blooms: Vec<_> = self
-            .layers
-            .values()
-            .par_bridge()
-            .map(|entry| {
-                let Ok(mut bloom) = Self::create_filter() else {
-                    tracing::warn!("TrieLayerCache: rebuild_bloom could not create filter");
-                    return None;
-                };
-                for (p, _) in entry.nodes.iter() {
-                    if let Err(qfilter::Error::CapacityExceeded) = bloom.insert(p) {
-                        tracing::warn!("TrieLayerCache: rebuild_bloom capacity exceeded");
-                        return None;
-                    }
-                }
-                Some(bloom)
-            })
-            .collect();
-
-        let Some(mut ret) = blooms.pop().flatten() else {
-            tracing::warn!("TrieLayerCache: rebuild_bloom no valid bloom found");
+        let Ok(mut new_global_filter) = Self::create_filter() else {
+            tracing::warn!(
+                "TrieLayerCache: rebuild_bloom could not create new filter. Poisoning bloom."
+            );
             self.bloom = None;
             return;
         };
-        for bloom in blooms.iter() {
-            let Some(bloom) = bloom else {
-                tracing::warn!("TrieLayerCache: rebuild_bloom no valid bloom found");
-                self.bloom = None;
-                return;
-            };
-            if let Err(qfilter::Error::CapacityExceeded) = ret.merge(false, bloom) {
-                tracing::warn!("TrieLayerCache: rebuild_bloom capacity exceeded");
-                self.bloom = None;
-                return;
+
+        for layer in self.layers.values() {
+            for path in layer.nodes.keys() {
+                if let Err(qfilter::Error::CapacityExceeded) = new_global_filter.insert(path) {
+                    tracing::warn!(
+                        "TrieLayerCache: rebuild_bloom capacity exceeded. Poisoning bloom."
+                    );
+                    self.bloom = None;
+                    return;
+                }
             }
         }
-        self.bloom = Some(ret);
+
+        self.bloom = Some(new_global_filter);
     }
 
     pub fn commit(&mut self, state_root: H256) -> Option<Vec<(Vec<u8>, Vec<u8>)>> {