feat(reflect-cpp): Switched from glaze -> reflect cpp

A bug was discovered in glaze which prevented valid toml output. We have
switched to toml++ and reflect-cpp. The interface has remained the same
so this should not break any code

build-config/reflect-cpp/include/rfl/parsing/schemaful/IsSchemafulReader.hpp

@@ -0,0 +1,66 @@
+#ifndef RFL_PARSING_SCHEMAFUL_ISSCHEMAFULREADER_HPP_
+#define RFL_PARSING_SCHEMAFUL_ISSCHEMAFULREADER_HPP_
+
+#include <concepts>
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "../../Result.hpp"
+
+namespace rfl::parsing::schemaful {
+
+using MockVariantType = std::variant<std::string, int>;
+
+template <class R>
+struct MockMapReader {
+  void read(const std::string_view&, typename R::InputVarType&) const {}
+};
+
+template <class R>
+struct MockObjectReader {
+  void read(const int, typename R::InputVarType&) const {}
+};
+
+template <class R>
+struct MockUnionReader {
+  static rfl::Result<MockVariantType> read(const R&, const size_t,
+                                           typename R::InputVarType&) {
+    return error("This is a mock type.");
+  }
+};
+
+template <class R>
+concept IsSchemafulReader =
+    requires(R r, typename R::InputVarType var, typename R::InputObjectType obj,
+             typename R::InputMapType m, typename R::InputUnionType u,
+             MockMapReader<R> map_reader, MockObjectReader<R> object_reader) {
+      /// A schemaful reader needs to differentiate between objects, for which
+      /// the field names are known at compile time and maps, for which the
+      /// field names are not known at compile time.
+      { r.read_map(map_reader, m) } -> std::same_as<std::optional<Error>>;
+
+      /// A schemaful reader can read fields by order and does not have to
+      /// compare strings - the correct order of the fields is guaranteed by the
+      /// schema.
+      {
+        r.read_object(object_reader, obj)
+      } -> std::same_as<std::optional<Error>>;
+
+      /// A schemaful reader needs an explicit union type.
+      {
+        r.template read_union<MockVariantType, MockUnionReader<R>>(u)
+      } -> std::same_as<rfl::Result<MockVariantType>>;
+
+      /// It needs to be possible to transform variables to maps.
+      { r.to_map(var) } -> std::same_as<rfl::Result<typename R::InputMapType>>;
+
+      /// It needs to be possible to transform variables to unions.
+      {
+        r.to_union(var)
+      } -> std::same_as<rfl::Result<typename R::InputUnionType>>;
+    };
+
+}  // namespace rfl::parsing::schemaful
+
+#endif