Mirror reactive MtuExceeded into path_mtu_lookup

When a transit forwarder drops an oversized data packet and reports
the bottleneck back via MtuExceeded, the receive-side handler
already updates per-session MmpSessionState::path_mtu (used by PTB
synthesis to feed kernel TCP). It did not, however, update
path_mtu_lookup — the per-destination map the TUN reader/writer
consult at TCP MSS clamp time. So forward-path-asymmetry flows kept
clamping at the discovery reverse-path value (too generous for the
actual forward-path budget) on every subsequent SYN.

Add the missing write at the same point apply_notification runs.
Keep the tighter of existing-or-new — the clamp must never loosen.
Same write-shape as seed_path_mtu_for_link_peer.

Tests:

- Three focused unit tests on handle_mtu_exceeded for the empty,
  tighten, and keep-tighter cases.
- Extended test_multihop_pmtud_heterogeneous_mtu to assert the
  lookup tightens after the wire-level MtuExceeded propagation,
  alongside its existing PathMtuState assertion.

Adds two #[cfg(test)] accessors on Node (path_mtu_lookup_get /
path_mtu_lookup_insert) and bumps handle_mtu_exceeded to
pub(in crate::node) for direct test invocation.

src/node/mod.rs

@@ -1581,6 +1581,23 @@ impl Node {
         self.sessions.remove(remote)
     }
 
+    /// Read the path_mtu_lookup entry for a destination FipsAddress.
+    #[cfg(test)]
+    pub(crate) fn path_mtu_lookup_get(&self, fips_addr: &crate::FipsAddress) -> Option<u16> {
+        self.path_mtu_lookup
+            .read()
+            .ok()
+            .and_then(|map| map.get(fips_addr).copied())
+    }
+
+    /// Write a path_mtu_lookup entry directly (for tests that pre-seed the map).
+    #[cfg(test)]
+    pub(crate) fn path_mtu_lookup_insert(&self, fips_addr: crate::FipsAddress, mtu: u16) {
+        if let Ok(mut map) = self.path_mtu_lookup.write() {
+            map.insert(fips_addr, mtu);
+        }
+    }
+
     /// Number of end-to-end sessions.
     pub fn session_count(&self) -> usize {
         self.sessions.len()