Refactor job system and update project configuration

Added:
- Added `JobExecutor.cs` for job execution management.
- Added `JobInfo.cs` to hold job execution information.
- Added `TestJobSystem.cs` for unit tests of the job system.
- Added `TestJobs.cs` for additional job implementation tests.
- Added `WorkerThread.cs` to manage worker threads for jobs.

Changed:
- Changed `AssemblyInfo.cs.cs` to include a global using directive for `unsafe JobExecuteFunc`.
- Changed `IJob.cs` to include an overload of the `Execute` method with a `threadIndex` parameter.
- Changed `JobHandle.cs` to include an `IsValid` property and updated internal structure.
- Changed `JobScheduler.cs` to improve job scheduling and management.
- Changed `JobsUtility.cs` to enhance job management functions.
- Changed `MemoryBlock.cs` to reference the heap from which memory was allocated.
- Changed `ParallelNoiseBenchmark.cs` to include benchmarks for the job system.
- Changed `Program.cs` to execute benchmarks instead of previous test code.

Removed:
- Removed `.gitignore` entries for default ignored files.
- Removed `JobBase.cs` to shift from structs to classes for jobs.
- Removed `JobExtensions.cs` indicating a change in job scheduling.
- Removed `JobStruct.cs` indicating a change in job structure.
- Removed `encodings.xml`, `indexLayout.xml`, and `vcs.xml` files to simplify project configuration.
- Removed fields from `JobData.cs` to simplify the job data structure.
- Removed `TestJobSystem.csproj` entries related to old project structure.

Misaki.HighPerformance.LowLevel/Buffer/MemoryBlock.cs

@@ -16,6 +16,14 @@ public unsafe readonly struct MemoryBlock
         get;
     }
 
+    /// <summary>
+    /// The heap from which the memory was allocated.
+    /// </summary>
+    public void* Heap
+    {
+        get;
+    }
+
     /// <summary>
     /// Size of the allocated memory in bytes.
     /// </summary>
@@ -43,9 +51,10 @@ public unsafe readonly struct MemoryBlock
     /// <param name="ptr">Pointer to the allocated memory.</param>
     /// <param name="size">Size of the allocated memory.</param>
     /// <param name="alignment">Alignment of the allocated memory.</param>
-    public MemoryBlock(void* ptr, nuint size, nuint alignment)
+    public MemoryBlock(void* ptr, void* heap, nuint size, nuint alignment)
     {
         Ptr = ptr;
+        Heap = heap;
         Size = size;
         Alignment = alignment;
     }
@@ -53,7 +62,7 @@ public unsafe readonly struct MemoryBlock
     /// <summary>
     /// Creates an invalid MemoryBlock.
     /// </summary>
-    public static MemoryBlock Invalid => new(null, 0, 0);
+    public static MemoryBlock Invalid => new(null, null, 0, 0);
 
     public Span<T> AsSpan<T>()
         where T : unmanaged