Condense fetch log time trace

#1762 added
automatic fetch trace logging for each individual file extracted from a
`.zip` file. Many of these operations are very fast, especially for
`otatools.zip` and take many lines of logs. These should be condensed
since they don't contribute much to the overall time and make the trace
harder to read.

Sample new output:
```
Performance stats:
PreFetch actions:
 started: 2025-11-25 15:52:13, duration: 1 s
 - GetBuilds: 1 s
Host Package:
 started: 2025-11-25 15:52:14, duration: 3 m 13 s
 - Download: 3 m 6 s, 851 MiB
 - Extract: 6 s
 - 2 operations omitted with a combined duration of 12 ms.
Default:
 started: 2025-11-25 15:52:14, duration: 7 m 33 s
 - Downloaded 'misc_info.txt': 1 s, 9000 B
 - Downloaded 'aosp_cf_x86_64_only_phone-img-14496483.zip': 7 m 23 s, 1135 MiB
 - Extracted 'super.img' from 'aosp_cf_x86_64_only_phone-img-14496483.zip': 7 s, 1339 MiB
 - Desparsed [/super.img]: 933 ms, 8192 MiB
 - 22 operations omitted with a combined duration of 549 ms.
Kernel:
 started: 2025-11-25 15:59:47, duration: 8 ms
 - 4 operations omitted with a combined duration of 8 ms.
OTA Tools:
 started: 2025-11-25 15:59:47, duration: 1 m 54 s
 - Downloaded 'otatools.zip': 1 m 51 s, 486 MiB
 - 14653 operations omitted with a combined duration of 3 s.
```

Bug: b/463765667

Author: Databean

base/cvd/cuttlefish/host/commands/cvd/fetch/fetch_tracer.cpp

@@ -33,7 +33,7 @@ namespace {
 
 struct Phase {
   std::string name;
-  std::chrono::seconds duration;
+  std::chrono::milliseconds duration;
   std::optional<size_t> size_bytes;
 };
 
@@ -49,6 +49,14 @@ struct FetchTracer::TraceImpl {
 
 namespace {
 
+std::chrono::milliseconds FullDuration(const FetchTracer::TraceImpl& trace) {
+  std::chrono::milliseconds total_duration;
+  for (const Phase& phase : trace.phases) {
+    total_duration += phase.duration;
+  }
+  return total_duration;
+}
+
 std::string FormatByteSize(uint64_t size) {
   if (size < 10240) {
     return fmt::format("{} B", size);
@@ -69,16 +77,42 @@ std::string FormatByteSize(uint64_t size) {
   return fmt::format("{} TiB", size);
 }
 
+std::string FormatDuration(std::chrono::milliseconds duration_ms) {
+  if (duration_ms < std::chrono::milliseconds(1000)) {
+    return fmt::format("{} ms", duration_ms.count());
+  }
+  std::chrono::seconds duration_s =
+      std::chrono::duration_cast<std::chrono::seconds>(duration_ms);
+  if (duration_s < std::chrono::seconds(60)) {
+    return fmt::format("{} s", duration_s.count());
+  } else {
+    return fmt::format("{} m {} s", duration_s.count() / 60,
+                       duration_s.count() % 60);
+  }
+}
+
 std::string ToStyledString(const FetchTracer::TraceImpl& trace,
                            std::string indent_prefix) {
   std::stringstream ss;
+  size_t omitted_count = 0;
+  std::chrono::milliseconds omitted_time(0);
   for (const Phase& phase : trace.phases) {
-    ss << indent_prefix << phase.name << ": " << phase.duration.count() << "s";
+    if (phase.duration < std::chrono::milliseconds(500)) {
+      omitted_count++;
+      omitted_time += phase.duration;
+      continue;
+    }
+    ss << indent_prefix << phase.name << ": " << FormatDuration(phase.duration);
     if (phase.size_bytes) {
       ss << ", " << FormatByteSize(*phase.size_bytes);
     }
     ss << '\n';
   }
+  if (omitted_count > 0) {
+    ss << indent_prefix;
+    ss << omitted_count << " operations omitted with a combined duration of "
+       << FormatDuration(omitted_time) << ".\n";
+  }
   return ss.str();
 }
 
@@ -91,7 +125,8 @@ void FetchTracer::Trace::CompletePhase(std::string phase_name,
   auto now = std::chrono::steady_clock::now();
   impl_.phases.push_back(Phase{
       std::move(phase_name),
-      std::chrono::duration_cast<std::chrono::seconds>(now - impl_.phase_start),
+      std::chrono::duration_cast<std::chrono::milliseconds>(now -
+                                                            impl_.phase_start),
       size_bytes});
   impl_.phase_start = now;
 }
@@ -110,7 +145,7 @@ std::string FetchTracer::ToStyledString() const {
         std::chrono::system_clock::to_time_t(trace->trace_start);
     ss << name << ":\n";
     ss << " started: " << std::put_time(std::localtime(&start_time), "%F %T")
-       << '\n';
+       << ", duration: " << FormatDuration(FullDuration(*trace)) << '\n';
     ss << cuttlefish::ToStyledString(*trace, " - ");
   }
   return ss.str();