[BUG] Dependency injection w/ useAsyncFactory returns Promise on 2nd invoke()
### Describe the bug

I'm having a problem with the typeorm adapter, where I'm injecting the Datasource into my services & controllers, and I'm encountering situations where the injected value is a Promise instead of the registered Datasource instance.

### To Reproduce

I've created a test that seems to replicate the behavior below.  Unfortunately, I'm not very familiar with the DI codebase so I wasn't sure that it made sense for me to attempt to create a PR to address this issue.

```patch
--- forkSrcPrefix/packages/di/src/common/decorators/inject.spec.ts
+++ forkDstPrefix/packages/di/src/common/decorators/inject.spec.ts
@@ -40,6 +40,42 @@ describe("@Inject()", () => {
       expect(instance).toBeInstanceOf(Test);
       expect(instance.test).toBeInstanceOf(InjectorService);
     });
+    it("should inject service w/ async factory", async () => {
+      // GIVEN
+      class Test {
+        constructor(public type: string) {}
+      }
+
+      const TokenAsync = Symbol.for("MyService");
+
+      registerProvider<Test>({
+        provide: TokenAsync,
+        type: "test:async",
+        deps: [],
+        useAsyncFactory() {
+          return Promise.resolve(new Test("async"));
+        }
+      });
+
+      @Injectable()
+      class Parent1 {
+        @Inject(TokenAsync)
+        test: Test;
+      }
+
+      @Injectable()
+      class Parent2 {
+        @Inject(TokenAsync)
+        test: Test;
+      }
+
+      const injector = new InjectorService();
+      const parent1 = await injector.invoke<Parent1>(Parent1);
+      const parent2 = await injector.invoke<Parent2>(Parent2);
+
+      expect(parent1.test).toBeInstanceOf(Test);
+      expect(parent2.test).toBeInstanceOf(Test);
+    });
     it("should inject service with the given type", async () => {
       // GIVEN
       @Injectable()
```

### Expected behavior

I expect to be able to use code like this throughout my services & controllers:

```typescript
@Inject(PrimaryPostgresDb) protected dataSource: DataSource;
```

with a typeorm adapter that looks like:

```typescript
export const PrimaryPostgresDb = Symbol.for("PrimaryPostgresDb");
export const PrimaryDataSource = new DataSource(typeOrmSettings);

registerProvider<DataSource>({
  provide: PrimaryPostgresDb,
  type: "typeorm:datasources",
  deps: [Logger],
  useAsyncFactory: async (logger: Logger) => {
    if (!PrimaryDataSource.isInitialized) {
      await PrimaryDataSource.initialize();

      logger.info(
        `Connected with typeorm to database: ${PrimaryPostgresDb.toString()}`
      );
    }

    return PrimaryDataSource;
  },
  hooks: {
    $onDestroy: (dataSource) => {
      return dataSource.isInitialized && dataSource.destroy();
    },
  },
});
```

### Code snippets

_No response_

### Repository URL example

_No response_

### OS

osx

### Node version

v18.19.1

### Library version

v7.67.0

### Additional context

_No response_