Restrict bloom filter propagation to tree edges, update design docs

Gate peer_inbound_filters() to only collect from tree peers (parent
and children), so outgoing filter computation merges only tree-sourced
information. All peers still receive FilterAnnounce messages and store
filters locally for routing queries — the restriction is only on what
gets merged into outgoing filters.

This prevents bloom filter saturation where mesh shortcuts cause every
node's filter to converge toward the full network. With tree-only
merge, filters contain subtree (from children) + complement (from
parent) + single-hop mesh views.

Implementation:
- Add is_tree_peer() helper to determine tree parent/child relationship
- Gate peer_inbound_filters() to tree peers only (single control point)
- Trigger bloom filter exchange on tree relationship changes
- Add est_entries, set_bits, fill ratio, and tree_peer fields to
  FilterAnnounce send/receive debug logs
- Add test_bloom_filter_split_horizon test verifying directional
  asymmetry: upward filters contain only the child's subtree, downward
  filters contain only the complement
- Add print_filter_cardinality diagnostic helper for test inspection

Design docs:
- fips-bloom-filters.md: Add directional asymmetry and mesh peer filter
  subsections, update per-peer filter model, saturation mitigation,
  implementation status table
- fips-mesh-operation.md: Update filter propagation description, add
  directional asymmetry, tree relationship change trigger
- fips-intro.md: Rewrite bloom propagation paragraph for tree-only merge

src/node/mod.rs

@@ -972,6 +972,26 @@ impl Node {
 
     // === Routing ===
 
+    /// Check if a peer is a tree neighbor (parent or child in the spanning tree).
+    ///
+    /// Returns true if the peer is our current tree parent, or if the peer
+    /// has declared us as their parent (making them our child).
+    pub(crate) fn is_tree_peer(&self, peer_addr: &NodeAddr) -> bool {
+        // Peer is our parent
+        if !self.tree_state.is_root()
+            && self.tree_state.my_declaration().parent_id() == peer_addr
+        {
+            return true;
+        }
+        // Peer is our child (their declaration names us as parent)
+        if let Some(decl) = self.tree_state.peer_declaration(peer_addr)
+            && decl.parent_id() == self.node_addr()
+        {
+            return true;
+        }
+        false
+    }
+
     /// Find next hop for a destination node address.
     ///
     /// Routing priority: