Massively improve performance by rewriting the network core & rendering using burst jobs (#864)

* Add the Burst toolchain and project plumbing

Reference Unity.Burst, Unity.Collections, Unity.Mathematics and Unity.Jobs
from KSPBurst so the network model can be rewritten against the job system,
and pull in Krafs.Publicizer to expose UnityEngine.Object.m_CachedPtr (for
thread-safe null checks) and List<T>._items (for an AsSpan helper).

Expose internals to the RemoteTech.Tests and RemoteTech.InGameTests
assemblies, bump the language version to 13, and replace the .slnx with a
plain .sln.

* Add the RemoteTech.Collections helpers

Later work is going to need a number of utilities. This commit adds:
* an ArrayMap class that stores keys/values in arrays internally,
* an ArrayMinHeap struct that provides a burst-compatible min-heap,
* a number of extension helper methods for various types
* an ObjectHandle struct for passing managed types to burst jobs
* a IJobParallelForBatchDefer interface and extensions

* Rewrite the network model as a Burst job pipeline

Replace the managed graph/route computation with an unmanaged pipeline built
on the Unity job system. Satellite and antenna state is projected into native
arrays (NetworkState) once per update, and connectivity, routing and the
render geometry are computed by Burst jobs (NetworkUpdate, Edges,
NetworkUpdateMath, and the line/cone/mark mesh jobs).

Antennas publish their state through a pinned AntennaData registered with
StateManager, so the jobs can read them without touching managed memory.
ISatellite gains a flat SatelliteState snapshot and Antennas becomes an
IReadOnlyList; NetworkLink/NetworkRoute become readonly struct views over the
store rather than heap-allocated objects. The range models are unified behind
IRangeModel so the job path and the managed path share one implementation.

NetworkManager drives the pipeline and NetworkRenderer draws the computed
meshes directly, replacing the per-frame NetworkCone/NetworkLine GameObjects.

* Add test harnesses for the network jobs

RemoteTech.Tests runs the Burst/NativeArray math headlessly under xunit by
backing native arrays with Marshal.AllocHGlobal (NativeArena), covering the
range/geometry math. RemoteTech.InGameTests is a KSP.Testing plugin with an
in-game runner UI that exercises the jobs against real Unity Collections
(adjacency, edges, Dijkstra, mark/cone geometry, hashing).

* Migrate the API onto the NetworkState read seam

Route the public API methods through the precomputed NetworkState instead
of the old on-demand LINQ/route materialization:

- Add a GetRoute passthrough to the NetworkManager read seam.
- GetFirstHopToKSC / GetControlPath now read the groundOnly route directly
  via GetRoute rather than filtering + Min()-ing over BuildConnections.
- HasDirectGroundStation / GetClosestDirectGroundStation now test the
  satellite's direct adjacency row (GetLinks) for a ground-station target.
  This treats any direct link to a ground station as qualifying (not only
  first hops of a shortest route) and drops the empty/self-route NRE and
  the empty-sequence Min() throw.
- Replace the O(n) Satellites.Where(...).FirstOrDefault() guid scans with
  the O(1) Satellites[id] indexer; GetName / GetRangeDistance use the
  Network[id] indexer so ground stations still resolve.

GetSignalDelayToSatellite's arbitrary A->B pathfind is left on
NetworkPathfinder; NetworkState has no point-to-point equivalent yet.

* Gate signal relay on transit rather than link existence

Relay capability now determines whether a node may forward a signal (transit),
not whether a link exists. IsEdgeTraversable previously required both endpoints
of every edge to be relay-capable, which wrongly disconnected powered non-relay
endpoints (e.g. passive-SPU vessels) — a route's own endpoints never forward, so
they should not need to relay.

ComputeAdjacencyLists now includes an edge whenever both endpoints are powered.
The relay check moves into a per-node CanTransit bitmask: the multi-source
Dijkstra records a node's score but only expands out of it when it can transit,
and roots (route endpoints) always expand.

* Add a point-to-point signal delay query to the API

Replace GetSignalDelayToSatellite's on-demand A* (NetworkPathfinder) with a
Burst NetworkPathfindJob run over the persisted NetworkState edge table, exposed
as NetworkState.ShortestDelayBetween plus a NetworkManager passthrough. Add the
NetworkUpdateMath.EncodePairIndex helper the job uses to index the triangular
edge table.

* Hide command-station routes rooted at filtered-out vessels

The multi-path overlay drew every tree edge in the command-station
forest, so a vessel hidden by the map view filter still showed its green
route back to control. Seed the on-path set by walking the predecessor
forest from each visible vessel instead, so a route is drawn only when a
visible vessel sits at its far end.

* Remove dead network-model code superseded by NetworkState

The migration onto the Burst NetworkState left the old managed routing
orphaned. Delete the A* NetworkPathfinder and the explicit-mode half of
NetworkRoute it fed (the freestanding-path ctor, Empty, Contains, and the
BidirectionalEdge it compared against), leaving the live value-type view
into the Dijkstra forests. Drop the unused NetworkManager.FindNeighbors /
ConnectionCache / Count, the NetworkState.GetRouteLength / GetRouteOrigin
guid wrappers (callers use the internal index versions), the unused
VesselSatellite.Connections seam, and the never-referenced Dish type.

* Properly install CKAN deps in CI

* Use KSPBT for the tests project

Author: Phantomical

.gitignore

@@ -167,3 +167,6 @@ GameData/RemoteTech/Plugins/RemoteTech.xml
 GameData/RemoteTech/Versioning/RemoteTech.version
 GameData/build.txt
 src/RemoteTech/RemoteTech.sln.ide/
+
+# In-game test plugin build output (the source lives under tests/)
+GameData/RemoteTech.Tests/

RemoteTech.sln

@@ -0,0 +1,40 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RemoteTech", "src\RemoteTech\RemoteTech.csproj", "{67470554-F754-4664-AC7C-D002943ACD72}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RemoteTech.Tests", "tests\RemoteTech.Tests\RemoteTech.Tests.csproj", "{A7585803-6434-436E-BFC1-B09A520425D7}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RemoteTech.InGameTests", "tests\RemoteTech.InGameTests\RemoteTech.InGameTests.csproj", "{C5C1CBBB-83DD-4850-A6F8-6823AB14B54E}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{065AC022-06A2-4079-9DEC-051B87D76A08}"
+	ProjectSection(SolutionItems) = preProject
+		CHANGES.md = CHANGES.md
+		CONTRIBUTING.md = CONTRIBUTING.md
+		README.md = README.md
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{67470554-F754-4664-AC7C-D002943ACD72}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{67470554-F754-4664-AC7C-D002943ACD72}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{67470554-F754-4664-AC7C-D002943ACD72}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{67470554-F754-4664-AC7C-D002943ACD72}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A7585803-6434-436E-BFC1-B09A520425D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A7585803-6434-436E-BFC1-B09A520425D7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A7585803-6434-436E-BFC1-B09A520425D7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A7585803-6434-436E-BFC1-B09A520425D7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C5C1CBBB-83DD-4850-A6F8-6823AB14B54E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C5C1CBBB-83DD-4850-A6F8-6823AB14B54E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C5C1CBBB-83DD-4850-A6F8-6823AB14B54E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C5C1CBBB-83DD-4850-A6F8-6823AB14B54E}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

RemoteTech.slnx

@@ -3,7 +3,9 @@
 
 namespace RemoteTech.AddOns
 {
-    /// <summary> Simple class to detect if Kerbalism is loaded </summary>
+    /// <summary>
+    /// Simple class to detect if Kerbalism is loaded
+    /// </summary>
     public static class Kerbalism
     {
         private static readonly Type API;
@@ -21,7 +23,9 @@ static Kerbalism()
             }
         }
 
-        /// <summary> Returns true if Kerbalism is detected for the current game </summary>
+        /// <summary>
+        /// Returns true if Kerbalism is detected for the current game
+        /// </summary>
         public static bool Exists
         {
             get { return API != null; }

src/RemoteTech/API/API.cs

@@ -15,14 +15,14 @@ public class AntennaManager : IDisposable, IEnumerable<IAntenna>
         public event Action<IAntenna> OnRegister = delegate { };
         public event Action<IAntenna> OnUnregister = delegate { };
 
-        public IEnumerable<IAntenna> this[ISatellite s] { get { return For(s.Guid); } }
-        public IEnumerable<IAntenna> this[Vessel v] { get { return For(v.id); } }
-        public IEnumerable<IAntenna> this[Guid g] { get { return For(g); } }
+        public IReadOnlyList<IAntenna> this[ISatellite s] { get { return For(s.Guid); } }
+        public IReadOnlyList<IAntenna> this[Vessel v] { get { return For(v.id); } }
+        public IReadOnlyList<IAntenna> this[Guid g] { get { return For(g); } }
 
         private readonly Dictionary<Guid, List<IAntenna>> mLoadedAntennaCache =
             new Dictionary<Guid, List<IAntenna>>();
-        private readonly Dictionary<Guid, List<IAntenna>> mProtoAntennaCache =
-            new Dictionary<Guid, List<IAntenna>>();
+        private readonly Dictionary<Guid, List<ProtoAntenna>> mProtoAntennaCache =
+            new Dictionary<Guid, List<ProtoAntenna>>();
 
         public AntennaManager()
         {
@@ -35,6 +35,15 @@ public AntennaManager()
         public void Dispose()
         {
             GameEvents.onVesselGoOnRails.Remove(OnVesselGoOnRails);
+
+            foreach (List<ProtoAntenna> antennas in mProtoAntennaCache.Values)
+            {
+                foreach (ProtoAntenna antenna in antennas)
+                {
+                    antenna.Dispose();
+                }
+            }
+            mProtoAntennaCache.Clear();
         }
 
         public void Register(Guid key, IAntenna antenna)
@@ -98,7 +107,7 @@ public void RegisterProtos(Vessel v)
                 {
                     if (!mProtoAntennaCache.ContainsKey(key))
                     {
-                        mProtoAntennaCache[key] = new List<IAntenna>();
+                        mProtoAntennaCache[key] = new List<ProtoAntenna>();
                     }
                     ProtoAntenna proto = new ProtoAntenna(v, pps, ppms);
                     mProtoAntennaCache[key].Add(proto);
@@ -113,25 +122,22 @@ public void UnregisterProtos(Guid key)
 
             if (!mProtoAntennaCache.ContainsKey(key)) return;
 
-            foreach (IAntenna a in mProtoAntennaCache[key])
+            foreach (ProtoAntenna a in mProtoAntennaCache[key])
             {
                 OnUnregister.Invoke(a);
+                a.Dispose();
             }
 
             mProtoAntennaCache.Remove(key);
         }
 
-        private IEnumerable<IAntenna> For(Guid key)
+        private IReadOnlyList<IAntenna> For(Guid key)
         {
             if (mLoadedAntennaCache.ContainsKey(key))
-            {
                 return mLoadedAntennaCache[key];
-            }
             if (mProtoAntennaCache.ContainsKey(key))
-            {
                 return mProtoAntennaCache[key];
-            }
-            return Enumerable.Empty<IAntenna>();
+            return [];
         }
 
         private void OnVesselGoOnRails(Vessel v)
@@ -163,11 +169,6 @@ public static bool IsAntenna(this ProtoPartModuleSnapshot ppms)
                    ppms.GetBool("IsRTActive");
         }
 
-        public static bool IsAntenna(this PartModule pm)
-        {
-            return pm.Fields.GetValue<bool>("IsRTAntenna") &&
-                   pm.Fields.GetValue<bool>("IsRTPowered") &&
-                   pm.Fields.GetValue<bool>("IsRTActive");
-        }
+        public static bool IsAntenna(this PartModule pm) => pm is IAntenna;
     }
 }

src/RemoteTech/AddOns/Kerbalism.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace RemoteTech.Collections;
+
+public class ArrayMap<K, V> : IEnumerable<KeyValuePair<K, V>>
+{
+    private readonly Dictionary<K, int> indices;
+    private readonly List<K> keys;
+    private readonly List<V> values;
+
+    public int Count => values.Count;
+    public V this[K key]
+    {
+        get => values[indices[key]];
+        set
+        {
+            if (indices.TryGetValue(key, out var index))
+            {
+                keys[index] = key;
+                values[index] = value;
+            }
+            else
+            {
+                index = values.Count;
+                indices.Add(key, index);
+                keys.Add(key);
+                values.Add(value);
+            }
+        }
+    }
+
+    public ReadOnlySpan<K> Keys => keys.AsReadOnlySpan();
+    public Span<V> Values => values.AsSpan();
+
+    public ArrayMap()
+    {
+        indices = [];
+        keys = [];
+        values = [];
+    }
+
+    public ArrayMap(int capacity)
+    {
+        indices = new(capacity);
+        keys = new(capacity);
+        values = new(capacity);
+    }
+
+    public bool TryGetValue(K key, out V value)
+    {
+        value = default;
+        if (!indices.TryGetValue(key, out var index))
+            return false;
+
+        value = values[index];
+        return true;
+    }
+
+    public bool ContainsKey(K key) => indices.ContainsKey(key);
+
+    public int IndexOf(K key) => indices.TryGetValue(key, out var index) ? index : -1;
+
+    public void Add(K key, V value)
+    {
+        var count = Count;
+        indices.Add(key, count);
+        keys.Add(key);
+        values.Add(value);
+    }
+
+    public bool TryAdd(K key, V value)
+    {
+        if (indices.ContainsKey(key))
+            return false;
+
+        var index = Count;
+        indices.Add(key, index);
+        keys.Add(key);
+        values.Add(value);
+        return true;
+    }
+
+    public bool Remove(K key)
+    {
+        if (!indices.TryGetValue(key, out var index))
+            return false;
+
+        if (index == Count - 1)
+        {
+            indices.Remove(key);
+            keys.RemoveAt(index);
+            values.RemoveAt(index);
+        }
+        else
+        {
+            var count = Count;
+            var other = keys[index] = keys[count - 1];
+            values[index] = values[count - 1];
+
+            indices[other] = index;
+            indices.Remove(key);
+            keys.RemoveAt(count - 1);
+            values.RemoveAt(count - 1);
+        }
+
+        return true;
+    }
+
+    public void Clear()
+    {
+        indices.Clear();
+        keys.Clear();
+        values.Clear();
+    }
+
+    public Enumerator GetEnumerator() => new(this);
+    IEnumerator<KeyValuePair<K, V>> IEnumerable<KeyValuePair<K, V>>.GetEnumerator() => GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public struct Enumerator(ArrayMap<K, V> map) : IEnumerator<KeyValuePair<K, V>>
+    {
+        List<K>.Enumerator keys = map.keys.GetEnumerator();
+        List<V>.Enumerator vals = map.values.GetEnumerator();
+
+        public KeyValuePair<K, V> Current => new(keys.Current, vals.Current);
+        object IEnumerator.Current => Current;
+
+        public bool MoveNext() => keys.MoveNext() & vals.MoveNext();
+
+        void IEnumerator.Reset()
+        {
+            DoReset(ref keys);
+            DoReset(ref vals);
+        }
+
+        public void Dispose() { }
+
+        private static void DoReset<T>(ref T enumerator)
+            where T : IEnumerator
+        {
+            enumerator.Reset();
+        }
+    }
+}