Add throughput and latency benchmarks for `absl::ToDoubleXYZ` functions.

Sample benchmark result on a Skylake machine:
```
name                                       time/op
BM_Duration_ToInt64Nanoseconds             1.506n ± 0%
BM_Duration_ToInt64Microseconds            1.499n ± 1%
BM_Duration_ToInt64Milliseconds            1.502n ± 1%
BM_Duration_ToInt64Seconds                 1.498n ± 1%
BM_Duration_ToInt64Minutes                 1.495n ± 1%
BM_Duration_ToInt64Hours                   1.502n ± 1%
BM_Duration_ToDoubleNanoseconds            1.589n ± 1%
BM_Duration_ToDoubleMicroseconds           1.712n ± 1%
BM_Duration_ToDoubleMilliseconds           1.712n ± 1%
BM_Duration_ToDoubleSeconds                1.715n ± 1%
BM_Duration_ToDoubleMinutes                1.716n ± 1%
BM_Duration_ToDoubleHours                  1.717n ± 1%
BM_Duration_ToDoubleNanoseconds_Latency    9.934n ± 1%
BM_Duration_ToDoubleMicroseconds_Latency   13.08n ± 0%
BM_Duration_ToDoubleMilliseconds_Latency   13.06n ± 0%
BM_Duration_ToDoubleSeconds_Latency        13.06n ± 1%
BM_Duration_ToDoubleMinutes_Latency        13.01n ± 1%
BM_Duration_ToDoubleHours_Latency          13.03n ± 1%
BM_Duration_ToTimespec_AbslTime            1.567n ± 1%
BM_Duration_ToTimespec_Double              1.282n ± 1%
geomean                                    2.920n
```

PiperOrigin-RevId: 822317999
Change-Id: I0055d0780c9039ee30be52bc284599a3bcb24f56

absl/time/duration_benchmark.cc

diff --git a/absl/time/duration_benchmark.cc b/absl/time/duration_benchmark.cc
index fdb26bb..e2dd4d2 100644
--- a/absl/time/duration_benchmark.cc
+++ b/absl/time/duration_benchmark.cc
@@ -359,6 +359,150 @@
 BENCHMARK(BM_Duration_ToInt64Hours);
 
 //
+// ToDoubleXYZ
+//
+void BM_Duration_ToDoubleNanoseconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleNanoseconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleNanoseconds);
+
+void BM_Duration_ToDoubleMicroseconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleMicroseconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMicroseconds);
+
+void BM_Duration_ToDoubleMilliseconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleMilliseconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMilliseconds);
+
+void BM_Duration_ToDoubleSeconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleSeconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleSeconds);
+
+void BM_Duration_ToDoubleMinutes(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleMinutes(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMinutes);
+
+void BM_Duration_ToDoubleHours(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleHours(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleHours);
+
+//
+// ToDoubleXYZ Latency
+//
+void BM_Duration_ToDoubleNanoseconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleNanoseconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleNanoseconds_Latency);
+
+void BM_Duration_ToDoubleMicroseconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleMicroseconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMicroseconds_Latency);
+
+void BM_Duration_ToDoubleMilliseconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleMilliseconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMilliseconds_Latency);
+
+void BM_Duration_ToDoubleSeconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleSeconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleSeconds_Latency);
+
+void BM_Duration_ToDoubleMinutes_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleMinutes(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMinutes_Latency);
+
+void BM_Duration_ToDoubleHours_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleHours(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleHours_Latency);
+
+//
 // To/FromTimespec
 //