feat(Production): Complete production deployment infrastructure

- Add comprehensive health check system with multiple endpoints
- Add Prometheus metrics endpoint
- Add production logging configurations (5 strategies)
- Add complete deployment documentation suite:
  * QUICKSTART.md - 30-minute deployment guide
  * DEPLOYMENT_CHECKLIST.md - Printable verification checklist
  * DEPLOYMENT_WORKFLOW.md - Complete deployment lifecycle
  * PRODUCTION_DEPLOYMENT.md - Comprehensive technical reference
  * production-logging.md - Logging configuration guide
  * ANSIBLE_DEPLOYMENT.md - Infrastructure as Code automation
  * README.md - Navigation hub
  * DEPLOYMENT_SUMMARY.md - Executive summary
- Add deployment scripts and automation
- Add DEPLOYMENT_PLAN.md - Concrete plan for immediate deployment
- Update README with production-ready features

All production infrastructure is now complete and ready for deployment.

src/Framework/DI/MethodInvoker.php

@@ -13,10 +13,13 @@ use App\Framework\Reflection\WrappedReflectionMethod;
  */
 final readonly class MethodInvoker
 {
+    private ParameterResolver $parameterResolver;
+
     public function __construct(
-        private Container       $container,
+        private Container $container,
         private ReflectionProvider $reflectionProvider
     ) {
+        $this->parameterResolver = new ParameterResolver($container, $reflectionProvider);
     }
 
     /**
@@ -87,56 +90,42 @@ final readonly class MethodInvoker
         return $nativeMethod->invokeArgs(null, $parameters);
     }
 
+    /**
+     * Erstellt eine neue Instanz mit automatischer Dependency Injection
+     * und optionalen Parameter-Overrides für den Constructor
+     *
+     * @template T of object
+     * @param class-string<T> $className
+     * @param array<string, mixed> $overrides Named constructor parameters
+     * @return T
+     */
+    public function make(string $className, array $overrides = []): object
+    {
+        $classNameObj = ClassName::create($className);
+        $reflection = $this->reflectionProvider->getClass($classNameObj);
+
+        if (! $reflection->isInstantiable()) {
+            throw new \InvalidArgumentException(
+                "Class '{$className}' is not instantiable (interface, abstract class, or trait)"
+            );
+        }
+
+        // Check if class has constructor
+        if (! $reflection->hasMethod('__construct')) {
+            return $reflection->newInstance();
+        }
+
+        // Resolve constructor parameters with overrides
+        $parameters = $this->resolveMethodParameters($classNameObj, '__construct', $overrides);
+
+        return $reflection->newInstance(...$parameters);
+    }
+
     /**
      * Löst alle Parameter einer Methode auf
      */
     private function resolveMethodParameters(ClassName $className, string $methodName, array $overrides): array
     {
-        $parameters = [];
-
-        // Framework ParameterCollection verwenden
-        $methodParameters = $this->reflectionProvider->getMethodParameters($className, $methodName);
-
-        foreach ($methodParameters as $param) {
-            $paramName = $param->getName();
-
-            // Override-Werte haben Priorität
-            if (array_key_exists($paramName, $overrides)) {
-                $parameters[] = $overrides[$paramName];
-
-                continue;
-            }
-
-            // Type-based injection mit Framework API
-            $typeName = $param->getTypeName();
-
-            if ($typeName !== null && ! $param->isBuiltin()) {
-                if ($this->container->has($typeName)) {
-                    $parameters[] = $this->container->get($typeName);
-
-                    continue;
-                }
-            }
-
-            // Default-Werte verwenden
-            if ($param->hasDefaultValue()) {
-                $parameters[] = $param->getDefaultValue();
-
-                continue;
-            }
-
-            // Nullable Parameter
-            if ($param->allowsNull()) {
-                $parameters[] = null;
-
-                continue;
-            }
-
-            throw new \InvalidArgumentException(
-                "Cannot resolve parameter '{$paramName}' for method '{$methodName}' on class '{$className->getFullyQualified()}'"
-            );
-        }
-
-        return $parameters;
+        return $this->parameterResolver->resolveMethodParameters($className, $methodName, $overrides);
     }
 }