chore: resolve forward-port conflicts in dedup tests, Dockerfile and lockfile

- deduplication.rs: take dev's deterministic test_dedup_service (#10393),
  keep the 3.x cancellation tests and their imports
- Dockerfile.repo: rust 1.99.0 on the 3.x trixie base
- Cargo.lock: keep terminal_size, still used on 3.x

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: rohan-b99

Cargo.lock

@@ -7695,7 +7695,6 @@ dependencies = [
  "once_cell",
  "rustix",
  "windows-sys 0.61.0",
-<<<<<<< HEAD
 ]
 
 [[package]]
@@ -7706,8 +7705,6 @@ checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
  "rustix",
  "windows-sys 0.61.0",
-=======
->>>>>>> origin/dev
 ]
 
 [[package]]

apollo-router/src/plugins/traffic_shaping/deduplication.rs

@@ -248,17 +248,14 @@ where
 
 #[cfg(test)]
 mod tests {
-<<<<<<< HEAD
     use std::time::Duration;
 
+    use futures::FutureExt;
     use futures::future::BoxFuture;
     use http::StatusCode;
     use tokio::time::Instant;
     use tower::BoxError;
     use tower::Layer;
-=======
-    use futures::FutureExt;
->>>>>>> origin/dev
     use tower::Service;
     use tower::ServiceExt;
     use tower_test::mock::Handle;
@@ -269,20 +266,7 @@ mod tests {
     use crate::services::SubgraphResponse;
     use crate::services::subgraph;
 
-<<<<<<< HEAD
-    // Testing strategy:
-    //  - Two calls with the same cache key are joined in the same task via tokio::join!.
-    //    join! polls fut1 first: it locks the wait_map, inserts an entry, calls the inner
-    //    service, and yields (pending on the mock response). join! then polls fut2: it finds
-    //    the entry and joins the shared fetch. Both are suspended before the driver ever
-    //    responds. This ordering is structural — cooperative scheduling in a single task —
-    //    not a timing assumption.
-    //  - The driver handles exactly one request. If dedup fails and fut2 reaches the inner
-    //    service a second time, the closed handle returns an error and res2 fails.
-    #[tokio::test(flavor = "multi_thread")]
-=======
     #[tokio::test]
->>>>>>> origin/dev
     async fn test_dedup_service() {
         let (mock, mut handle) = tower_test::mock::pair::<SubgraphRequest, SubgraphResponse>();
         let mut svc = QueryDeduplicationService::new(mock);
@@ -293,20 +277,10 @@ mod tests {
         svc.ready().await.expect("it is ready");
         let mut fut2 = svc.call(request);
 
-<<<<<<< HEAD
-        // tokio::join! polls fut1 first. fut1 inserts a wait_map entry and yields waiting
-        // for the inner service response. join! then polls fut2, which finds the entry and
-        // joins the shared fetch. Both are suspended before the driver responds,
-        // guaranteeing deduplication.
-        let (res1, res2) = tokio::join!(fut1, fut2);
-        res1.expect("fut1 joined");
-        res2.expect("fut2 joined");
-=======
         // Poll both callers before the mock answers: fut1 starts the fetch and fut2 subscribes
         // to its result.
         assert!(futures::poll!(&mut fut1).is_pending());
         assert!(futures::poll!(&mut fut2).is_pending());
->>>>>>> origin/dev
 
         let (req, responder) = handle.next_request().await.expect("the mock is called");
         assert!(

dockerfiles/diy/dockerfiles/Dockerfile.repo

@@ -5,11 +5,7 @@
 # environment specifically to support those hosts. Use an older build base
 # (or a static musl target) here if you need that compatibility instead.
 # renovate-automation: rustc version
-<<<<<<< HEAD
-FROM rust:1.98.1-slim-trixie as build
-=======
-FROM rust:1.99.0-slim-bookworm as build
->>>>>>> origin/dev
+FROM rust:1.99.0-slim-trixie as build
 
 # Set our working directory for the build
 WORKDIR /usr/src/router