Add 64-bit tick fast paths to `absl::IDivDuration`

When dividing a non-negative `Duration` up to `kint64max / kTicksPerSecond` (~73 years) by a positive sub-second divisor in `IDivFastPath`, compute quotient and remainder directly in `uint64_t` quarter-nanosecond ticks instead of falling back to 128-bit `uint128` division. In `IDivSlowPath`, also use 64-bit unsigned division when both `MakeU128Ticks` operands fit in `uint64_t` (`(Uint128High64(a) | Uint128High64(b)) == 0`).

PiperOrigin-RevId: 1011671250
diff --git a/absl/time/duration.cc b/absl/time/duration.cc
index 160e253..5a31f5d 100644
--- a/absl/time/duration.cc
+++ b/absl/time/duration.cc
@@ -314,6 +314,15 @@
         *rem = time_internal::MakeDuration(0, num_lo % den_lo);
         return true;
       }
+    } else if (den_lo != 0 && num_hi >= 0 &&
+               static_cast<uint64_t>(num_hi) <
+                   static_cast<uint64_t>(kint64max) / kTicksPerSecond) {
+      const uint64_t num_ticks =
+          static_cast<uint64_t>(num_hi) * kTicksPerSecond + num_lo;
+      *q = static_cast<int64_t>(num_ticks / den_lo);
+      *rem = time_internal::MakeDuration(
+          0, static_cast<uint32_t>(num_ticks % den_lo));
+      return true;
     }
   } else if (den_hi > 0 && den_lo == 0) {
     // Dividing by positive multiple of 1s
@@ -368,17 +377,29 @@
 
   const uint128 a = MakeU128Ticks(num);
   const uint128 b = MakeU128Ticks(den);
-  uint128 quotient128 = a / b;
-
-  if (satq) {
-    // Limits the quotient to the range of int64_t.
-    if (quotient128 > uint128(static_cast<uint64_t>(kint64max))) {
-      quotient128 = quotient_neg ? uint128(static_cast<uint64_t>(kint64min))
-                                 : uint128(static_cast<uint64_t>(kint64max));
+  uint128 quotient128;
+  uint128 remainder128;
+  if ((Uint128High64(a) | Uint128High64(b)) == 0) {
+    const uint64_t a64 = Uint128Low64(a);
+    const uint64_t b64 = Uint128Low64(b);
+    uint64_t q64 = a64 / b64;
+    if (satq && q64 > static_cast<uint64_t>(kint64max)) {
+      q64 = quotient_neg ? static_cast<uint64_t>(kint64min)
+                         : static_cast<uint64_t>(kint64max);
     }
+    quotient128 = q64;
+    remainder128 = a64 - q64 * b64;
+  } else {
+    quotient128 = a / b;
+    if (satq) {
+      // Limits the quotient to the range of int64_t.
+      if (quotient128 > uint128(static_cast<uint64_t>(kint64max))) {
+        quotient128 = quotient_neg ? uint128(static_cast<uint64_t>(kint64min))
+                                   : uint128(static_cast<uint64_t>(kint64max));
+      }
+    }
+    remainder128 = a - quotient128 * b;
   }
-
-  const uint128 remainder128 = a - quotient128 * b;
   *rem = MakeDurationFromU128(remainder128, num_neg);
 
   if (!quotient_neg || quotient128 == 0) {
diff --git a/absl/time/duration_test.cc b/absl/time/duration_test.cc
index 6645c53..c712c61 100644
--- a/absl/time/duration_test.cc
+++ b/absl/time/duration_test.cc
@@ -1909,4 +1909,47 @@
   EXPECT_EQ(alignof(NoPadding), alignof(absl::Duration));
 }
 
+TEST(Duration, IDivDurationFastPathBoundaries) {
+  // Exercise 64-bit tick IDivDuration boundaries around
+  // kint64max / kTicksPerSecond (2305843009s) and uint64_max / kTicksPerSecond
+  // (4611686018s) across both sub-second and multi-second divisors.
+  const absl::Duration kDivisors[] = {
+      absl::Nanoseconds(7) + absl::Nanoseconds(1) / 4,
+      absl::Seconds(1) + absl::Milliseconds(500),
+  };
+  for (absl::Duration den : kDivisors) {
+    for (int64_t sec :
+         {int64_t{0}, int64_t{1}, int64_t{2305843008}, int64_t{2305843009},
+          int64_t{2305843010}, int64_t{4611686018}, int64_t{4611686019}}) {
+      const absl::Duration num = absl::Seconds(sec) +
+                                 absl::Nanoseconds(999999999) +
+                                 absl::Nanoseconds(3) / 4;
+      absl::Duration rem;
+      const int64_t q = absl::IDivDuration(num, den, &rem);
+      if (q < std::numeric_limits<int64_t>::max()) {
+        EXPECT_EQ(num, q * den + rem);
+        EXPECT_GE(rem, absl::ZeroDuration());
+        EXPECT_LT(rem, den);
+      }
+      absl::Duration neg_rem;
+      EXPECT_EQ(-q, absl::IDivDuration(-num, den, &neg_rem));
+      EXPECT_EQ(-rem, neg_rem);
+      EXPECT_EQ(-q, absl::IDivDuration(num, -den, &neg_rem));
+      EXPECT_EQ(rem, neg_rem);
+      EXPECT_EQ(q, absl::IDivDuration(-num, -den, &neg_rem));
+      EXPECT_EQ(-rem, neg_rem);
+    }
+  }
+
+  // Exercise 64-bit IDivSlowPath saturation when ticks fit in uint64_t
+  // (4611686018s * 4e9 < 2^64) while quotient exceeds int64_t.
+  const absl::Duration large_u64 = absl::Seconds(4611686018);
+  const absl::Duration quarter_ns = absl::Nanoseconds(1) / 4;
+  absl::Duration sat_rem;
+  EXPECT_EQ(std::numeric_limits<int64_t>::min(),
+            absl::IDivDuration(large_u64, -quarter_ns, &sat_rem));
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(),
+            absl::IDivDuration(-large_u64, -quarter_ns, &sat_rem));
+}
+
 }  // namespace