fix(sync): Replace the latency “cliff” in EMA scoring with a continuous curve (#1451)

Right now quality drops from 1.0 to e^-1 immediately at the threshold.
This commit makes it continuous after the threshold.

**Before:**

```
threshold = 1.00s
  t(s)     quality
--------------------
  0.90    1.000000
  1.00    1.000000
  1.10    0.332871   <-- cliff
  1.20    0.301194
  1.30    0.272532
  1.40    0.246597
  1.50    0.223130
  1.60    0.201897
  1.70    0.182684
  1.80    0.165299
  1.90    0.149569
  2.00    0.135335
  2.10    0.122456
  2.20    0.110803
  2.30    0.100259
  2.40    0.090718
```

**After:**

```
threshold = 1.00s
  t(s)     quality
--------------------
  0.90    1.000000
  1.00    1.000000
  1.10    0.904837   <-- no cliff
  1.20    0.818731
  1.30    0.740818
  1.40    0.670320
  1.50    0.606531
  1.60    0.548812
  1.70    0.496585
  1.80    0.449329
  1.90    0.406570
  2.00    0.367879
  2.10    0.332871
  2.20    0.301194
  2.30    0.272532
  2.40    0.246597
```

Author: romac

code/crates/sync/src/scoring.rs

@@ -341,24 +341,23 @@ mod tests {
         });
     }
 
-    // Property: Slow responses should decrease the score
+    // Property: Slow responses should decrease the score if it was already high
     #[test]
-    fn slow_responses_decrease_score() {
+    fn slow_responses_decrease_high_score() {
         arbtest(|u| {
             let strategy = arb_strategy(u)?;
             let response_time = arb_response_time_slow(u, strategy.slow_threshold)?;
 
             let mut scorer = PeerScorer::new(strategy);
-            let peer_id = PeerId::random();
 
-            let initial_score = scorer.get_score(&peer_id);
+            let initial_score = 1.0;
             let update_score = scorer
                 .strategy
                 .update_score(initial_score, SyncResult::Success(response_time));
 
             assert!(
                 update_score < initial_score,
-                "Slow response should decrease score: {initial_score} -> {update_score}",
+                "Slow response ({response_time:?}) should decrease score: {initial_score} -> {update_score}",
             );
 
             Ok(())
@@ -528,7 +527,9 @@ mod tests {
     }
 
     // Property: Score updates should be monotonic for sequences of same result type
+    // Note: This test does not apply to EMA anymore, but it can be useful for testing other strategies that have more deterministic score changes.
     #[test]
+    #[ignore]
     fn monotonic_score_updates() {
         arbtest(|u| {
             let strategy = arb_strategy(u)?;
@@ -539,6 +540,11 @@ mod tests {
             let mut current_score = scorer.strategy.initial_score(PeerId::random());
             let mut scores = vec![current_score];
 
+            println!(
+                "Testing monotonicity for result {:?} over {} updates, threshold={:?}",
+                result, update_count, strategy.slow_threshold
+            );
+
             for _ in 0..update_count {
                 current_score = scorer.strategy.update_score(current_score, result);
                 scores.push(current_score);
@@ -552,18 +558,18 @@ mod tests {
                         let diff = window[1] - window[0];
                         assert!(
                             diff >= 0.0,
-                            "Fast response should improve score: {} -> {}",
+                            "Fast response ({rt:?}) should improve score: {} -> {}",
                             window[0],
                             window[1]
                         );
                     }
                 }
-                SyncResult::Success(_) => {
+                SyncResult::Success(rt) => {
                     // For slow responses, scores should decrease
                     for window in scores.windows(2) {
                         assert!(
                             window[1] <= window[0],
-                            "Slow response should decrease score: {} -> {}",
+                            "Slow response ({rt:?}) should decrease score: {} -> {}",
                             window[0],
                             window[1]
                         );

code/crates/sync/src/scoring/ema.rs

@@ -78,18 +78,29 @@ impl ScoringStrategy for ExponentialMovingAverage {
     fn update_score(&mut self, previous_score: Score, result: SyncResult) -> Score {
         match result {
             SyncResult::Success(response_time) => {
+                let response_time_secs = response_time.as_secs_f64();
+                let threshold_secs = self.slow_threshold.as_secs_f64();
+
                 // Calculate quality score between 0-1 based on response time
-                // We use an exponential decay function to penalize slow responses more heavily
-                let quality = if response_time < self.slow_threshold {
-                    // Fast responses get a high quality score
+                // We use an exponential decay function to penalize slow responses more heavily.
+                let quality = if response_time_secs <= threshold_secs {
                     1.0
                 } else {
-                    // Slow responses get a low quality score based on how slow they were
-                    (-response_time.as_secs_f64() / self.slow_threshold.as_secs_f64()).exp()
+                    // Decay from the threshold, ensuring a smooth drop-off
+                    (-(response_time_secs - threshold_secs) / threshold_secs).exp()
                 };
 
                 // Update score with EMA using alpha_success
-                self.alpha_success * quality + (1.0 - self.alpha_success) * previous_score
+                let new_score =
+                    self.alpha_success * quality + (1.0 - self.alpha_success) * previous_score;
+
+                #[cfg(test)]
+                {
+                    println!("Response time: {response_time_secs:.3}s, Quality: {quality:.3}");
+                    println!(" => Updating score: prev={previous_score:.3}, new={new_score:.3}");
+                }
+
+                new_score
             }
 
             SyncResult::Timeout => {