perf(dash-spv): size storage segments per item type

Every segment cache held 50 000 items, whatever an item costs. Near the
tip a block segment holds tens of MB of decoded blocks, while a header
segment spanning the same heights is 5.6 MB and a filter header one
1.6 MB. `Persistable::ITEMS_PER_SEGMENT` lets each type choose: headers
10 000 (~1.1 MB per segment), filter headers 50 000 (~1.6 MB), filters
2 000 (~2 MB near the tip) and blocks 1 000.

This changes the on-disk layout of the header, filter and block
segments. Storage written with 50 000-item segments is misread by this
layout and has to be deleted until a migration or a versioned folder
lands.

Mainnet restore, mainnet.100mbi.100ms, #1015/#1016/#1014 applied, two
resident segments, jemalloc heap profiling, wallet identical in every
run (14114383 sat, 7112 records, 13389 addresses):

  segment items           time          peak RSS      segment caches
  50 000 for every type   7.0 min       818 MiB       332 MiB
  5 000 for every type    7.3-8.3 min   554-687 MiB   23-106 MiB
  1 000 for every type    9.2-12.2 min  453-577 MiB   2-66 MiB
  per type (this commit)  7.5 min       538 MiB       38 MiB

With 1 000 items everywhere, the header and filter header phases paid an
fsync per evicted segment (105-141 s and 254-332 s instead of ~60 s and
~150 s). Blocks at 500 items saved ~18 MiB of cache but reloaded 50 %
more block segments.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DruChNTWXwJoWPartZwCf

Author: ZocoLini

dash-spv/src/storage/segments.rs

@@ -27,6 +27,7 @@ use crate::{
 pub trait Persistable: Sized + Encodable + Decodable + PartialEq + Clone {
     const SEGMENT_PREFIX: &'static str = "segment";
     const DATA_FILE_EXTENSION: &'static str = "dat";
+    const ITEMS_PER_SEGMENT: u32;
 
     fn segment_file_name(segment_id: u32) -> String {
         format!("{}_{:04}.{}", Self::SEGMENT_PREFIX, segment_id, Self::DATA_FILE_EXTENSION)
@@ -36,12 +37,16 @@ pub trait Persistable: Sized + Encodable + Decodable + PartialEq + Clone {
 }
 
 impl Persistable for Vec<u8> {
+    const ITEMS_PER_SEGMENT: u32 = 2_000;
+
     fn sentinel() -> Self {
         vec![]
     }
 }
 
 impl Persistable for HashedBlockHeader {
+    const ITEMS_PER_SEGMENT: u32 = 10_000;
+
     fn sentinel() -> Self {
         let header = BlockHeader {
             version: Version::from_consensus(i32::MAX), // Invalid version
@@ -57,12 +62,16 @@ impl Persistable for HashedBlockHeader {
 }
 
 impl Persistable for FilterHeader {
+    const ITEMS_PER_SEGMENT: u32 = 50_000;
+
     fn sentinel() -> Self {
         FilterHeader::from_byte_array([0u8; 32])
     }
 }
 
 impl Persistable for HashedBlock {
+    const ITEMS_PER_SEGMENT: u32 = 1_000;
+
     fn sentinel() -> Self {
         let block = Block {
             header: *HashedBlockHeader::sentinel().header(),
@@ -562,7 +571,7 @@ pub struct Segment<I: Persistable> {
 }
 
 impl<I: Persistable> Segment<I> {
-    const ITEMS_PER_SEGMENT: u32 = 50_000;
+    const ITEMS_PER_SEGMENT: u32 = I::ITEMS_PER_SEGMENT;
 
     fn new(segment_id: u32, mut items: Vec<I>, state: SegmentState) -> Self {
         debug_assert!(items.len() <= Self::ITEMS_PER_SEGMENT as usize);