fix(cli): old setInterval remains and is not cleared in garbage collection (#32985)

### Issue # (if applicable)

Related to #32742 

### Reason for this change
In the `garbageCollectS3` and `garbageCollectEcr` functions, a new `setInterval` is created in the `ProgressPrinter` class each time the for-await loop runs.
As a result, the old `setInterval` can no longer be referenced via `this.setInterval`, and because it cannot be cleared, the messages continue to be displayed.

https://github.com/aws/aws-cdk/blob/899965d6147829b8f8ac52ac8c1350de50d7b6d0/packages/aws-cdk/lib/api/garbage-collection/progress-printer.ts#L44

This behavior is the same as what occurs in the simple sample code below.
```ts
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

class Printer {
  private setInterval?: ReturnType<typeof setTimeout>

  public start() {
    this.setInterval = setInterval(() => {
      console.log("Hello, world!")
    }, 1000)
  }

  public stop() {
    clearInterval(this.setInterval)
  }
}

;(async () => {
  const printer = new Printer()

  // print one message per second for 5 seconds
  printer.start()
  await sleep(5000)

  // print tow messages per second for 5 seconds
  printer.start()
  await sleep(5000)

  // clear the newer setInterval
  // the older one will still be running
  printer.stop()
})()
```

### Description of changes
It didn't seem necessary to initialize `setInterval` each time the for-await loop runs, so I modified the code to call `.start()` before the loop begins.

### Describe any new or updated permissions being added
Nothing.

### Description of how you validated changes

### Checklist
- [x] My code adheres to the [CONTRIBUTING GUIDE](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and [DESIGN GUIDELINES](https://github.com/aws/aws-cdk/blob/main/docs/DESIGN_GUIDELINES.md)

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: sakurai-ryo

packages/aws-cdk/lib/api/garbage-collection/garbage-collector.ts

@@ -251,9 +251,10 @@ export class GarbageCollector {
 
       debug(`Parsing through ${numImages} images in batches`);
 
+      printer.start();
+
       for await (const batch of this.readRepoInBatches(ecr, repo, batchSize, currentTime)) {
         await backgroundStackRefresh.noOlderThan(600_000); // 10 mins
-        printer.start();
 
         const { included: isolated, excluded: notIsolated } = partition(batch, asset => !asset.tags.some(t => activeAssets.contains(t)));
 
@@ -323,12 +324,13 @@ export class GarbageCollector {
 
       debug(`Parsing through ${numObjects} objects in batches`);
 
+      printer.start();
+
       // Process objects in batches of 1000
       // This is the batch limit of s3.DeleteObject and we intend to optimize for the "worst case" scenario
       // where gc is run for the first time on a long-standing bucket where ~100% of objects are isolated.
       for await (const batch of this.readBucketInBatches(s3, bucket, batchSize, currentTime)) {
         await backgroundStackRefresh.noOlderThan(600_000); // 10 mins
-        printer.start();
 
         const { included: isolated, excluded: notIsolated } = partition(batch, asset => !activeAssets.contains(asset.fileName()));
 

packages/aws-cdk/lib/api/garbage-collection/progress-printer.ts

@@ -1,6 +1,7 @@
 import * as chalk from 'chalk';
 import { GcAsset as GCAsset } from './garbage-collector';
 import { info } from '../../logging';
+import { ToolkitError } from '../../toolkit/error';
 
 export class ProgressPrinter {
   private totalAssets: number;
@@ -41,6 +42,13 @@ export class ProgressPrinter {
   }
 
   public start() {
+    // If there is already a running setInterval, throw an error.
+    // This is because if this.setInterval is reassigned to another setInterval,
+    // the original setInterval remains and can no longer be cleared.
+    if (this.setInterval) {
+      throw new ToolkitError('ProgressPrinter is already running. Stop it first using the stop() method before starting it again.');
+    }
+
     this.setInterval = setInterval(() => {
       if (!this.isPaused) {
         this.print();

packages/aws-cdk/test/api/garbage-collection.test.ts

@@ -20,6 +20,7 @@ import {
   BackgroundStackRefresh,
   BackgroundStackRefreshProps,
 } from '../../lib/api/garbage-collection/stack-refresh';
+import { ProgressPrinter } from '../../lib/api/garbage-collection/progress-printer';
 import {
   BatchDeleteImageCommand,
   BatchGetImageCommand,
@@ -1002,6 +1003,33 @@ describe('BackgroundStackRefresh', () => {
   });
 });
 
+describe('ProgressPrinter', () => {
+  let progressPrinter: ProgressPrinter;
+  let setInterval: jest.SpyInstance;
+  let clearInterval: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    setInterval = jest.spyOn(global, 'setInterval');
+    clearInterval = jest.spyOn(global, 'clearInterval');
+
+    progressPrinter = new ProgressPrinter(0, 1000);
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    setInterval.mockRestore();
+    clearInterval.mockRestore();
+  });
+
+  test('throws if start is called twice without stop', () => {
+    progressPrinter.start();
+
+    expect(setInterval).toHaveBeenCalledTimes(1);
+    expect(() => progressPrinter.start()).toThrow('ProgressPrinter is already running. Stop it first using the stop() method before starting it again.');
+  });
+});
+
 function daysInThePast(days: number): Date {
   const d = new Date();
   d.setDate(d.getDate() - days);