Add TryCatchNode to represent try-catch operation

---

For more details, open the [Copilot Workspace session](https://copilot-workspace.githubnext.com/VisualNodeDev/NodeDev?shareId=XXXX-XXXX-XXXX-XXXX).

Author: snakex64

src/NodeDev.Core/Nodes/Flow/TryCatchNode.cs

@@ -0,0 +1,47 @@
+using NodeDev.Core.Connections;
+using NodeDev.Core.Types;
+using System.Linq.Expressions;
+
+namespace NodeDev.Core.Nodes.Flow;
+
+public class TryCatchNode : FlowNode
+{
+    public override bool IsFlowNode => true;
+
+    public TryCatchNode(Graph graph, string? id = null) : base(graph, id)
+    {
+        Name = "TryCatch";
+
+        Inputs.Add(new("Exec", this, TypeFactory.ExecType));
+
+        Outputs.Add(new("Try", this, TypeFactory.ExecType));
+        Outputs.Add(new("Catch", this, TypeFactory.ExecType));
+        Outputs.Add(new("Finally", this, TypeFactory.ExecType));
+        Outputs.Add(new("Exception", this, TypeFactory.Get<Exception>(), linkedExec: Outputs[1]));
+    }
+
+    public override string GetExecOutputPathId(string pathId, Connection execOutput)
+    {
+        return pathId + "-" + execOutput.Id;
+    }
+
+    public override bool DoesOutputPathAllowDeadEnd(Connection execOutput) => false;
+
+    public override bool DoesOutputPathAllowMerge(Connection execOutput) => true;
+
+    internal override Expression BuildExpression(Dictionary<Connection, Graph.NodePathChunks>? subChunks, BuildExpressionInfo info)
+    {
+        ArgumentNullException.ThrowIfNull(subChunks);
+
+        var tryBlock = Expression.Block(Graph.BuildExpression(subChunks[Outputs[0]], info));
+        var catchBlock = Expression.Block(Graph.BuildExpression(subChunks[Outputs[1]], info));
+        var finallyBlock = Expression.Block(Graph.BuildExpression(subChunks[Outputs[2]], info));
+
+        var exceptionVariable = Expression.Variable(typeof(Exception), "ex");
+        info.LocalVariables[3] = exceptionVariable; // Make sure other pieces of code use the right variable for that exception
+
+        var catchClause = Expression.Catch(exceptionVariable, catchBlock);
+
+        return Expression.TryCatchFinally(tryBlock, finallyBlock, catchClause);
+    }
+}

src/NodeDev.Tests/GraphExecutorTests.cs

@@ -142,4 +142,56 @@ public void TestProjectRun(SerializableBuildOptions options)
 		output = graph.SelfClass.Project.Run(options, [-1, -2]);
 		Assert.Equal(1, output);
 	}
-}
+
+    // This test validates the TryCatchNode by simulating a scenario where an exception is thrown and caught.
+    // The test sets up a graph with an entry node, a TryCatchNode, and return nodes for both try and catch blocks.
+    // The try block attempts to parse an invalid integer string, which throws an exception.
+    // The catch block returns 1, indicating that the exception was caught.
+    // The test asserts that the output is 1, confirming that the exception was caught and handled correctly.
+    [Theory]
+    [MemberData(nameof(GetBuildOptions))]
+    public void TestTryCatchNode(SerializableBuildOptions options)
+    {
+        var project = new Project(Guid.NewGuid());
+        var nodeClass = new NodeClass("Program", "Test", project);
+        project.Classes.Add(nodeClass);
+
+        var graph = new Graph();
+        var method = new NodeClassMethod(nodeClass, "Main", nodeClass.TypeFactory.Get<int>(), graph);
+        method.IsStatic = true;
+        nodeClass.Methods.Add(method);
+        graph.SelfMethod = nodeClass.Methods.First();
+
+        var entryNode = new Core.Nodes.Flow.EntryNode(graph);
+        var tryCatchNode = new Core.Nodes.Flow.TryCatchNode(graph);
+
+        graph.AddNode(entryNode, false);
+        graph.AddNode(tryCatchNode, false);
+
+        graph.Connect(entryNode.Outputs[0], tryCatchNode.Inputs[0], false);
+
+        var catchReturnNode = new Core.Nodes.Flow.ReturnNode(graph);
+        catchReturnNode.Inputs.Add(new("Result", catchReturnNode, nodeClass.TypeFactory.Get<int>()));
+        catchReturnNode.Inputs[1].UpdateTextboxText("1");
+        graph.AddNode(catchReturnNode, false);
+        graph.Connect(tryCatchNode.Outputs[1], catchReturnNode.Inputs[0], false);
+
+        var parseNode = new Core.Nodes.MethodCall(graph);
+        parseNode.SetMethodTarget(typeof(int).GetMethod("Parse", new[] { typeof(string) })!);
+        parseNode.Inputs[0].UpdateTextboxText("invalid");
+        graph.AddNode(parseNode, false);
+        graph.Connect(tryCatchNode.Outputs[0], parseNode.Inputs[0], false);
+
+        var tryReturnNode = new Core.Nodes.Flow.ReturnNode(graph);
+        tryReturnNode.Inputs.Add(new("Result", tryReturnNode, nodeClass.TypeFactory.Get<int>()));
+        tryReturnNode.Inputs[1].UpdateTextboxText("0");
+        graph.AddNode(tryReturnNode, false);
+		// Both the try and finally merge to the same "return", as there is nothing to actually put in the "finally" we can reuse the same return for simplicity
+        graph.Connect(parseNode.Outputs[0], tryReturnNode.Inputs[0], false);
+        graph.Connect(tryCatchNode.Outputs[2], tryReturnNode.Inputs[0], false);
+
+        var output = graph.Project.Run(options, Array.Empty<object>());
+
+        Assert.Equal(1, output);
+    }
+}