feat: Update bandwidth and latency calculations in SyntheticSampler for improved accuracy

    """Simple sampler with temporal continuity - next values stay close to previous values.

    Bandwidth ranges based on connection count:

      0 conns: avg=5%,  range 0-10%

      1 conn:  avg=25%, range 10-40%

      2 conns: avg=45%, range 30-60%

      3 conns: avg=65%, range 50-80%

      4+ conns: avg=85%, range 70-90%

    Latency scales proportionally with bandwidth (0% BW → 1ms, 100% BW → 20ms).

    Values vary by ±5% between consecutive samples for realistic jitter.

      0 conns: avg=3%,   range 1-10%

      1 conn:  avg=25%,  range 15-30%

      2 conns: avg=45%,  range 35-55%

      3 conns: avg=65%,  range 60-80%

      4+ conns: avg=85%, range 80-95%

    Latency uses bandwidth ranges divided by 10 (0-10ms):

      0 conns: avg=0.3ms, range 0.1-1.0ms

      1 conn:  avg=2.5ms, range 1.5-3.0ms

      2 conns: avg=4.5ms, range 3.5-5.5ms

      3 conns: avg=6.5ms, range 6.0-8.0ms

      4+ conns: avg=8.5ms, range 8.0-9.5ms

    Values vary by ±1% between consecutive samples for temporal continuity.

    """

    connection_count : int             = field(default = 0)     # Current connection count

    link_capacity    : float           = field(default = 100.0) # Link capacity in Gbps

    prev_latency     : Optional[float] = field(default = None)  # Previous latency (ms)

    # Connection count to (avg, min, max) percentage mapping

    # Latency uses same ranges divided by 10 (0-10ms range)

    BW_RANGES = {

        0: (3,  1,  10),

        1: (25, 15, 30),

        bw_utilization = max(min_bw, min(max_bw, bw_utilization))

        self.prev_bw   = bw_utilization

        # Latency scales proportionally with bandwidth (1ms at 0%, 20ms at 100%)

        target_latency = 1.0 + (bw_utilization / 100.0) * 19.0

        # Generate latency using same pattern as bandwidth (BW ranges / 10 = 0-10ms range)

        avg_lat  = avg / 10.0

        min_lat  = min_bw / 10.0

        max_lat  = max_bw / 10.0

        if self.prev_latency is None:

            latency = target_latency

            # First sample: start at average for this connection count

            latency = avg_lat

        else:

            # Add ±1% noise to previous latency

            # Add ±1% noise to previous latency for temporal continuity

            noise_factor = random.uniform(-0.01, 0.01)

            latency      = self.prev_latency * (1.0 + noise_factor)

        # Clamp latency to reasonable range

        latency           = max(0.5, min(25.0, latency))

        # Clamp to current range (handles "jump" when connection count changes)

        latency           = max(min_lat, min(max_lat, latency))

        self.prev_latency = latency

        # Convert percentage to actual utilization (Gbps)