Cardano Updates

The Router's route matching failed on GitHub Pages because the app is
served from /ce-netsim/ but routes were defined relative to /. Set the
Router's base prop via a compile-time env var (LEPTOS_BASE_PATH) so
it works both locally (defaults to "") and on GitHub Pages (/ce-netsim).

Rework the NetSim stack for time management and better performances

into_inner() takes self by value so Drop cannot have run yet,
making the data always Some. Added doc comment explaining this
and replaced generic expect with an actionable panic message.

PacketLoss::Rate now wraps a PacketLossRate newtype enforcing 0.0..=1.0.
PacketLoss::rate(f64) rejects NaN, negative, and >1.0 values with a
typed PacketLossRateError. Display formats as percentage (e.g. "5%",
"12.30%") and FromStr parses back. Error types use thiserror.

Replace saturating_mul with checked_mul in Bandwidth::FromStr so that
values exceeding u64::MAX (e.g. "99999999999gbps") return a clear error
instead of silently clamping to Bandwidth::MAX.

Rework Bandwidth::Display to always pick the largest SI unit and show up
to 2 decimal places with trailing zeros trimmed (e.g. 1.5kbps, 4.19gbps,
18446744073.71gbps).

Makes the minimum supported Rust version explicit so that cargo and CI
can reject incompatible toolchains early.

The previous implementation widened to u128 for the multiplication,
then divided by 8_000_000 in u128. On x86-64 the u128 division
compiles to __udivti3 — a slow software routine that caused 17-82%
regressions in the advance benchmarks.

Split the computation into quotient/remainder so all arithmetic stays
in u64: q×µs + (r×µs)/8_000_000. The remainder is always < 8_000_000,
so r×µs fits u64 for steps up to ~26.7 days.

Benchmarks after the fix show 15-49% improvement over the previous
version.

Add 22 new tests covering previously-untested code paths:
- node/mod.rs: default settings, upload/download bandwidth and buffer setters
- transit.rs: latency gating, buffer-overflow corruption, sender-buffer-full
  error, zero-byte packet edge case
- route.rs: accessor methods, direction selection based on node ID order
- network/mod.rs: Default, node/link accessors, packets_in_transit, round
  advancement, set_seed determinism, download bandwidth via builder
- download.rs + upload.rs: accessor method delegation

Fix static mut in packet.rs test (forbidden in edition 2024) by replacing
with AtomicU8. Add #[derive(Debug)] to Transit<T> so it can be used in
Result::unwrap_err().

Coverage: 88.9% → 90.1%+ (node/mod.rs 71→100%, route.rs 78→100%,
network/mod.rs 93→99%).

PacketBuilder::build() previously used anyhow::bail! for missing-field
errors, making it impossible for callers to match on specific failure
cases. Introduce a PacketBuildError enum (MissingSender, MissingRecipient,
MissingData) via thiserror, consistent with the pattern used by
RouteError, SendError, and PacketLossRateError.

Update the downstream netsim crate's SendToError::FailedToBuildMessage
to wrap PacketBuildError instead of anyhow::Error.

Bytes on a wire cannot arrive at the receiver faster than the
receiver's interface speed. When a link's bandwidth exceeds the
downstream node's download bandwidth, excess bytes now remain in
the link's pending buffer (still on the wire) instead of being
pushed to the download channel and triggering false corruption.

- Add `Download::available_capacity()` returning
  `min(channel_remaining, buffer_remaining)`
- Add `max_output` parameter to `LinkChannel::process()` so the
  link only releases what the receiver can absorb
- Wire up flow control in `Transit::advance()`
- Add integration test reproducing the demo topology
  (1 Gbps link → 200 Mbps client, 1 MB packet delivers)

Delete the broken snapshot-based stats system from both crates.
Network now exposes node(), nodes(), link(), links(),
packets_in_transit(), and round() for direct read-only inspection.
Node/Link internal methods restricted to pub(crate); Link exposes
per-direction bandwidth via forward_bandwidth()/reverse_bandwidth().

The example was broken in two ways: no link was configured between nodes
(causing LinkNotFound on send), and the 1bps upload bandwidth could never
deliver a 12-byte packet in the 12 seconds of simulation time advanced.

Fixed by adding a configure_link call with 50ms latency and 100 Mbps link
bandwidth, and changing upload bandwidth to 10 Mbps. The example now
demonstrates latency gating (packet blocked at 10ms) then delivery (at 100ms).

RouteBuilder removed entirely. Route::new(from, link, to) takes all
components directly and infers LinkDirection from the node IDs.
Network::route() no longer computes direction itself. anyhow dependency
removed from route.rs. Route stays public (used by benchmarks).

Add doc comments and inline explanations for four previously
undocumented design decisions:
- gauge.free(u64::MAX) idiom in CongestionChannel
- Round counter wrap-around behaviour
- PacketIdGenerator overflow behaviour

The `inbounds: VecDeque<Packet<T>>` field and its `push_pending`/
`pop_pending` methods were never called anywhere. Delivered packets go
directly through the `advance_with` callback, making the per-node
queue dead code

The Network API (send, advance_with, route) had zero test coverage at the
integration level — all existing tests were on individual components. Add
13 tests covering: basic delivery, payload round-trip, latency, bandwidth
saturation, packet loss, all four SendError/RouteError variants, corruption
detection, multiple packets in flight, and bidirectional traffic.

Migrate every `FromStr` implementation in netsim-core from
`anyhow::Error` to purpose-built error types using `thiserror`:

- `NodeId` → `ParseIntError` (stdlib, no wrapper needed)
- `time::Duration` → `DurationParseError` (5 variants)
- `Latency` → `DurationParseError` (delegates to time module)
- `Bandwidth` → `BandwidthParseError` (5 variants)
- `Latitude/Longitude/Location/PathEfficiency` → `GeoParseError` (6 variants)

Move `anyhow` from `[dependencies]` to `[dev-dependencies]` in
netsim-core since it is now only used by doc test harnesses.

Consolidate all workspace dependency versions in the root `Cargo.toml`
and reference them with `dep.workspace = true` in both crate manifests.

Export the new error types (`BandwidthParseError`, `DurationParseError`,
`GeoError`, `GeoParseError`) from the crate root.