refactor(srp): add managed lifecycle cleanup seams

Invoke managed pipeline disposal and asset runtime cleanup from the native bridge lifecycle. Add Universal renderer and feature cleanup hooks plus regression probes to verify runtime cache teardown semantics.

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -738,6 +738,7 @@ private:
     void ReleaseManagedPipeline() const;
     void ReleaseManagedAsset() const;
     MonoObject* GetManagedAssetObject() const;
+    MonoMethod* ResolveDisposePipelineMethod(MonoObject* pipelineObject) const;
     MonoMethod* ResolveCreatePipelineMethod(MonoObject* assetObject) const;
     MonoMethod* ResolveConfigureCameraRenderRequestMethod(
         MonoObject* assetObject) const;
@@ -745,15 +746,19 @@ private:
         MonoObject* assetObject) const;
     MonoMethod* ResolveGetPipelineRendererAssetKeyMethod(
         MonoObject* assetObject) const;
+    MonoMethod* ResolveReleaseRuntimeResourcesMethod(
+        MonoObject* assetObject) const;
 
     MonoScriptRuntime* m_runtime = nullptr;
     std::weak_ptr<void> m_runtimeLifetime;
     Rendering::Pipelines::ManagedRenderPipelineAssetDescriptor m_descriptor;
     mutable uint32_t m_assetHandle = 0;
+    mutable MonoMethod* m_disposePipelineMethod = nullptr;
     mutable MonoMethod* m_createPipelineMethod = nullptr;
     mutable MonoMethod* m_configureCameraRenderRequestMethod = nullptr;
     mutable MonoMethod* m_getDefaultFinalColorSettingsMethod = nullptr;
     mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr;
+    mutable MonoMethod* m_releaseRuntimeResourcesMethod = nullptr;
     mutable bool m_ownsManagedAssetHandle = false;
     mutable bool m_assetCreationAttempted = false;
     mutable uint32_t m_pipelineHandle = 0;
@@ -1233,6 +1238,7 @@ bool MonoManagedRenderPipelineAssetRuntime::EnsureManagedAsset() const {
 
 void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedPipeline() const {
     m_pipelineCreationAttempted = false;
+    m_disposePipelineMethod = nullptr;
 
     if (!IsRuntimeAlive()) {
         m_pipelineHandle = 0;
@@ -1240,6 +1246,18 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedPipeline() const {
     }
 
     if (m_pipelineHandle != 0) {
+        MonoObject* const pipelineObject =
+            m_runtime->GetManagedObject(m_pipelineHandle);
+        MonoMethod* const disposeMethod =
+            ResolveDisposePipelineMethod(pipelineObject);
+        if (pipelineObject != nullptr && disposeMethod != nullptr) {
+            m_runtime->InvokeManagedMethod(
+                pipelineObject,
+                disposeMethod,
+                nullptr,
+                nullptr);
+        }
+
         m_runtime->DestroyExternalManagedObject(m_pipelineHandle);
         m_pipelineHandle = 0;
     }
@@ -1247,6 +1265,7 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedPipeline() const {
 
 void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
     ReleaseManagedPipeline();
+    m_releaseRuntimeResourcesMethod = nullptr;
     m_createPipelineMethod = nullptr;
     m_configureCameraRenderRequestMethod = nullptr;
     m_getDefaultFinalColorSettingsMethod = nullptr;
@@ -1262,6 +1281,17 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
         return;
     }
 
+    MonoObject* const assetObject = GetManagedAssetObject();
+    MonoMethod* const releaseRuntimeResourcesMethod =
+        ResolveReleaseRuntimeResourcesMethod(assetObject);
+    if (assetObject != nullptr && releaseRuntimeResourcesMethod != nullptr) {
+        m_runtime->InvokeManagedMethod(
+            assetObject,
+            releaseRuntimeResourcesMethod,
+            nullptr,
+            nullptr);
+    }
+
     if (m_assetHandle != 0 && ownsManagedAssetHandle) {
         m_runtime->DestroyExternalManagedObject(m_assetHandle);
     }
@@ -1275,6 +1305,19 @@ MonoObject* MonoManagedRenderPipelineAssetRuntime::GetManagedAssetObject() const
         : nullptr;
 }
 
+MonoMethod* MonoManagedRenderPipelineAssetRuntime::ResolveDisposePipelineMethod(
+    MonoObject* pipelineObject) const {
+    if (m_disposePipelineMethod == nullptr) {
+        m_disposePipelineMethod =
+            m_runtime->ResolveManagedMethod(
+                pipelineObject,
+                "DisposeInstance",
+                0);
+    }
+
+    return m_disposePipelineMethod;
+}
+
 MonoMethod* MonoManagedRenderPipelineAssetRuntime::ResolveCreatePipelineMethod(
     MonoObject* assetObject) const {
     if (m_createPipelineMethod == nullptr) {
@@ -1330,6 +1373,20 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyMethod(
     return m_getPipelineRendererAssetKeyMethod;
 }
 
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::ResolveReleaseRuntimeResourcesMethod(
+    MonoObject* assetObject) const {
+    if (m_releaseRuntimeResourcesMethod == nullptr) {
+        m_releaseRuntimeResourcesMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "ReleaseRuntimeResourcesInstance",
+                0);
+    }
+
+    return m_releaseRuntimeResourcesMethod;
+}
+
 class MonoManagedRenderPipelineBridge final
     : public Rendering::Pipelines::ManagedRenderPipelineBridge {
 public: