Introduce new Benchmark class and Patcher

This MR covers most of #151 (closed)

In detail, it includes:

• Introduction of the new benchmark and patcher types defined in #151 (closed), closes #142 (closed)
• Refactoring of many components, e.g. the K8s manager according to #151 (closed), closes #143 (closed)
• Allow setting arbitrary environment parameters, close mostly #98 (closed)
• Load configuration based on two YAML files, this closes the first part of #137 (closed)
• Allow to set Kafka and Zookeeper service names, closes #122 (closed)
• Usage of the new Workload Generator, closes #157 (closed)

TODOs before ready to merge:

• Remove hard coded parts, e.g. type of instances and loads, which is not actually loaded by configuration, see Resource and LoadDimension class in kotlin.
• Change ("patching") methods from the Kubernetes managers to actual patchers to fully resolve #143 (closed)
• Test everything inside Kubernetes.
• Clean up, remove old classes and benchmark types
• Add a NodeSelector Patcher to resolve #93 (closed)
• Maybe we need more Patchers to fully resolve #98 (closed), if more of the non environment parameters (such as K8s ResourceLimits, K8s Labels, ..) must be configurable (@she ?)
• Make namespace configurable moved to #155 (closed)

Feel free to expand this description and add TODOs

theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmark.kt

+package theodolite.benchmark
+
+import io.fabric8.kubernetes.api.model.KubernetesResource
+import io.fabric8.kubernetes.client.DefaultKubernetesClient
+import theodolite.k8s.K8sResourceLoader
+import theodolite.patcher.PatcherManager
+import theodolite.util.*
+import java.util.*
+
+class KubernetesBenchmark : Benchmark {
+    lateinit var name: String
+    lateinit var appResource: List<String>
+    lateinit var loadGenResource: List<String>
+    lateinit var resourceTypes: List<TypeName>
+    lateinit var loadTypes: List<TypeName>
+    lateinit var kafkaConfig: KafkaConfig
+
+    private fun loadKubernetesResources(resources: List<String>): List<Pair<String, KubernetesResource>> {
+        val basePath = "./../../../resources/main/yaml/"
+        val parser = YamlParser()
+        val loader = K8sResourceLoader(DefaultKubernetesClient().inNamespace("theodolite-she"))
+        return resources
+            .map { resource ->
+                val resourcePath = "$basePath/$resource"
+                val kind = parser.parse(resourcePath, HashMap<String, String>()::class.java)?.get("kind")!!
+                val k8sResource = loader.loadK8sResource(kind, resourcePath)
+                Pair(resource, k8sResource)
+            }
+    }
+
+    override fun buildDeployment(
+        load: LoadDimension,
+        res: Resource,
+        configurationOverrides: List<ConfigurationOverride>
+    ): BenchmarkDeployment {
+        val resources = loadKubernetesResources(this.appResource + this.loadGenResource)
+        val patcherManager = PatcherManager()
+
+        // patch res and load
+        patcherManager.createAndApplyPatcher(res.getType(), this.resourceTypes, resources, res.get())
+        patcherManager.createAndApplyPatcher(load.getType(), this.loadTypes, resources, load.get().toString())
+
+        // patch overrides
+        configurationOverrides.forEach { override ->
+            patcherManager.applyPatcher(
+                listOf(override.patcher),
+                resources,
+                override.value
+            )
+        }
+
+        return KubernetesBenchmarkDeployment(
+            resources = resources.map { r -> r.second },
+            kafkaConfig = hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer),
+            topics = kafkaConfig.getKafkaTopics()
+        )
+    }
+}