Refactor to unify scripts/categories as Executable

This commit consolidates scripts and categories under a unified
'Executable' concept. This simplifies the architecture and improves code
readability.

- Introduce subfolders within `src/domain` to segregate domain elements.
- Update class and interface names by removing the 'I' prefix in
  alignment with new coding standards.
- Replace 'Node' with 'Executable' to clarify usage; reserve 'Node'
  exclusively for the UI's tree component.

tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { FunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter';
+import { testParameterName } from '../../ParameterNameTestRunner';
+
+describe('FunctionParameter', () => {
+  describe('name', () => {
+    testParameterName(
+      (parameterName) => new FunctionParameterBuilder()
+        .withName(parameterName)
+        .build()
+        .name,
+    );
+  });
+  describe('isOptional', () => {
+    describe('sets as expected', () => {
+      // arrange
+      const expectedValues = [true, false];
+      for (const expected of expectedValues) {
+        it(expected.toString(), () => {
+          // act
+          const sut = new FunctionParameterBuilder()
+            .withIsOptional(expected)
+            .build();
+          // expect
+          expect(sut.isOptional).to.equal(expected);
+        });
+      }
+    });
+  });
+});
+
+class FunctionParameterBuilder {
+  private name = 'parameterFromParameterBuilder';
+
+  private isOptional = false;
+
+  public withName(name: string) {
+    this.name = name;
+    return this;
+  }
+
+  public withIsOptional(isOptional: boolean) {
+    this.isOptional = isOptional;
+    return this;
+  }
+
+  public build() {
+    return new FunctionParameter(this.name, this.isOptional);
+  }
+}

tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
+
+describe('FunctionParameterCollection', () => {
+  it('all returns added parameters as expected', () => {
+    // arrange
+    const expected = [
+      new FunctionParameterStub().withName('1'),
+      new FunctionParameterStub().withName('2').withOptional(true),
+      new FunctionParameterStub().withName('3').withOptional(false),
+    ];
+    const sut = new FunctionParameterCollection();
+    for (const parameter of expected) {
+      sut.addParameter(parameter);
+    }
+    // act
+    const actual = sut.all;
+    // assert
+    expect(expected).to.deep.equal(actual);
+  });
+  it('throws when function parameters have same names', () => {
+    // arrange
+    const parameterName = 'duplicate-parameter';
+    const expectedError = `duplicate parameter name: "${parameterName}"`;
+    const sut = new FunctionParameterCollection();
+    sut.addParameter(new FunctionParameterStub().withName(parameterName));
+    // act
+    const act = () => sut.addParameter(
+      new FunctionParameterStub().withName(parameterName),
+    );
+    // assert
+    expect(act).to.throw(expectedError);
+  });
+});

tests/unit/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { createFunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
+import { itIsTransientFactory } from '@tests/unit/shared/TestCases/TransientFactoryTests';
+
+describe('FunctionParameterCollectionFactory', () => {
+  describe('createFunctionParameterCollection', () => {
+    describe('it is a transient factory', () => {
+      itIsTransientFactory({
+        getter: () => createFunctionParameterCollection(),
+        expectedType: FunctionParameterCollection,
+      });
+    });
+    it('returns an empty collection', () => {
+      // arrange
+      const expectedInitialParametersCount = 0;
+      // act
+      const collection = createFunctionParameterCollection();
+      // assert
+      expect(collection.all).to.have.lengthOf(expectedInitialParametersCount);
+    });
+  });
+});