refactor(di): modularize and improve dependency injection for deno

- Consolidate import paths into scoped modules for better structure.
- Refactor decorators (`Inject`, `Register`) for improved type safety.
- Add `clear` method to the DI container for easier test cleanup.
- Introduce lazy initialization for registered instances.
- Add comprehensive unit tests for decorators and DI container.
- Standardize error handling and naming conventions for exceptions.

Signed-off-by: Max P. <Mail@MPassarello.de>

tests/TSInjex.ts

@@ -0,0 +1,78 @@
+// deno-coverage-ignore-file
+// deno-lint-ignore-file
+import {
+    assertEquals,
+    assertStrictEquals,
+    assertThrows,
+} from "https://deno.land/std@0.224.0/assert/mod.ts";
+import { TSinjex } from "../src/classes/mod.ts";
+
+const container = TSinjex.getInstance() as TSinjex;
+
+Deno.test("should register and resolve a dependency (instance)", () => {
+    container.clear();
+
+    const identifier = "myDependency";
+    const dependency = { value: 42 };
+
+    container.register(identifier, dependency);
+
+    const resolved = container.resolve<typeof dependency>(identifier);
+    assertStrictEquals(resolved, dependency);
+});
+
+Deno.test("should register and resolve a dependency (static)", () => {
+    container.clear();
+
+    const identifier = "myDependency";
+    const dependency = { value: 42 };
+
+    TSinjex.register(identifier, dependency);
+    const resolved = TSinjex.resolve<typeof dependency>(identifier);
+
+    assertStrictEquals(resolved, dependency);
+});
+
+Deno.test("should throw error when resolving non-registered dependency (static)", () => {
+    container.clear();
+
+    const identifier = "nonExistentDependency";
+    assertThrows(() => {
+        TSinjex.resolve<unknown>(identifier);
+    });
+});
+
+Deno.test("should return undefined when resolving non-necessary dependency", () => {
+    container.clear();
+
+    const result = TSinjex.resolve<unknown>("nonExistentDependency", false);
+    assertEquals(result, undefined);
+});
+
+Deno.test("should warn when resolving a deprecated dependency", () => {
+    container.clear();
+
+    const identifier = "deprecatedDependency";
+    const dependency = { value: 42 };
+
+    // Mock console.warn
+    const originalWarn = console.warn;
+    let wasCalled = false;
+    let lastMessage = "";
+
+    console.warn = (msg: string) => {
+        wasCalled = true;
+        lastMessage = msg;
+    };
+
+    try {
+        TSinjex.register(identifier, dependency, true);
+        const resolved = TSinjex.resolve<typeof dependency>(identifier);
+        assertStrictEquals(resolved, dependency);
+        if (!wasCalled) {
+            throw new Error("console.warn was not called");
+        }
+    } finally {
+        console.warn = originalWarn; // Restore
+    }
+});