Introduce new TreeView UI component

Key highlights:

- Written from scratch to cater specifically to privacy.sexy's
  needs and requirements.
- The visual look mimics the previous component with minimal changes,
  but its internal code is completely rewritten.
- Lays groundwork for future functionalities like the "expand all"
  button a flat view mode as discussed in #158.
- Facilitates the transition to Vue 3 by omitting the Vue 2.0 dependent
  `liquour-tree` as part of #230.

Improvements and features:

- Caching for quicker node queries.
- Gradual rendering of nodes that introduces a noticable boost in
  performance, particularly during search/filtering.
  - `TreeView` solely governs the check states of branch nodes.

Changes:

- Keyboard interactions now alter the background color to highlight the
  focused item. Previously, it was changing the color of the text.
- Better state management with clear separation of concerns:
  - `TreeView` exclusively manages indeterminate states.
  - `TreeView` solely governs the check states of branch nodes.
  - Introduce transaction pattern to update state in batches to minimize
    amount of events handled.
- Improve keyboard focus, style background instead of foreground. Use
  hover/touch color on keyboard focus.
- `SelectableTree` has been removed. Instead, `TreeView` is now directly
  integrated with `ScriptsTree`.
- `ScriptsTree` has been refactored to incorporate hooks for clearer
  code and separation of duties.
- Adopt Vue-idiomatic bindings instead of keeping a reference of the
  tree component.
- Simplify and change filter event management.
- Abandon global styles in favor of class-scoped styles.
- Use global mixins with descriptive names to clarify indended
  functionality.

tests/unit/presentation/components/Scripts/View/Tree/TreeView/UseCurrentTreeNodes.spec.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ref, defineComponent, WatchSource, nextTick,
+} from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import { TreeRoot } from '@/presentation/components/Scripts/View/Tree/TreeView/TreeRoot/TreeRoot';
+import { InjectionKeys } from '@/presentation/injectionSymbols';
+import { UseAutoUnsubscribedEventsStub } from '@tests/unit/shared/Stubs/UseAutoUnsubscribedEventsStub';
+import { QueryableNodesStub } from '@tests/unit/shared/Stubs/QueryableNodesStub';
+import { TreeNodeCollectionStub } from '@tests/unit/shared/Stubs/TreeNodeCollectionStub';
+import { TreeRootStub } from '@tests/unit/shared/Stubs/TreeRootStub';
+import { useCurrentTreeNodes } from '@/presentation/components/Scripts/View/Tree/TreeView/UseCurrentTreeNodes';
+
+describe('useCurrentTreeNodes', () => {
+  it('should set nodes on immediate invocation', () => {
+    // arrange
+    const expectedNodes = new QueryableNodesStub();
+    const treeWatcher = ref<TreeRoot>(new TreeRootStub().withCollection(
+      new TreeNodeCollectionStub().withNodes(expectedNodes),
+    ));
+    // act
+    const { returnObject } = mountWrapperComponent(treeWatcher);
+    // assert
+    expect(returnObject.nodes.value).to.deep.equal(expectedNodes);
+  });
+
+  it('should update nodes when treeWatcher changes', async () => {
+    // arrange
+    const initialNodes = new QueryableNodesStub();
+    const treeWatcher = ref(
+      new TreeRootStub().withCollection(new TreeNodeCollectionStub().withNodes(initialNodes)),
+    );
+    const { returnObject } = mountWrapperComponent(treeWatcher);
+    const newExpectedNodes = new QueryableNodesStub();
+    // act
+    treeWatcher.value = new TreeRootStub().withCollection(
+      new TreeNodeCollectionStub().withNodes(newExpectedNodes),
+    );
+    await nextTick();
+    // assert
+    expect(returnObject.nodes.value).to.deep.equal(newExpectedNodes);
+  });
+
+  it('should update nodes when tree collection nodesUpdated event is triggered', async () => {
+    // arrange
+    const initialNodes = new QueryableNodesStub();
+    const treeCollectionStub = new TreeNodeCollectionStub().withNodes(initialNodes);
+    const treeWatcher = ref(new TreeRootStub().withCollection(treeCollectionStub));
+
+    const { returnObject } = mountWrapperComponent(treeWatcher);
+
+    const newExpectedNodes = new QueryableNodesStub();
+    // act
+    treeCollectionStub.triggerNodesUpdatedEvent(newExpectedNodes);
+    await nextTick();
+    // assert
+    expect(returnObject.nodes.value).to.deep.equal(newExpectedNodes);
+  });
+});
+
+function mountWrapperComponent(treeWatcher: WatchSource<TreeRoot | undefined>) {
+  let returnObject: ReturnType<typeof useCurrentTreeNodes>;
+  const wrapper = shallowMount(
+    defineComponent({
+      setup() {
+        returnObject = useCurrentTreeNodes(treeWatcher);
+      },
+      template: '<div></div>',
+    }),
+    {
+      provide: {
+        [InjectionKeys.useAutoUnsubscribedEvents as symbol]:
+          () => new UseAutoUnsubscribedEventsStub().get(),
+      },
+    },
+  );
+  return {
+    wrapper,
+    returnObject,
+  };
+}