refactor(serde): simplify type_info_of to constexpr function and add schema_opaque trait

- Replace type_info_instance struct specializations with a single
  constexpr type_info_of<T, Config>() function using if-constexpr dispatch
- Add schema_opaque<T> trait to opt out types from recursive schema decomposition
- Format with clang-format

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 16bit-ykiko

include/eventide/serde/schema/field_info.h

@@ -97,9 +97,13 @@ struct type_info {
         return kind == type_kind::float32 || kind == type_kind::float64;
     }
 
-    constexpr bool is_numeric() const { return is_integer() || is_floating(); }
+    constexpr bool is_numeric() const {
+        return is_integer() || is_floating();
+    }
 
-    constexpr bool is_scalar() const { return kind <= type_kind::enumeration; }
+    constexpr bool is_scalar() const {
+        return kind <= type_kind::enumeration;
+    }
 };
 
 /// array / set
@@ -149,12 +153,22 @@ struct field_info {
     const type_info* type;                      // recursive type descriptor (wire view)
 
     // Level 1 flags
-    bool has_default;    // schema::default_value
-    bool is_literal;     // schema::literal
-    bool has_skip_if;    // behavior::skip_if present
-    bool has_behavior;   // with/as/enum_string present
+    bool has_default;   // schema::default_value
+    bool is_literal;    // schema::literal
+    bool has_skip_if;   // behavior::skip_if present
+    bool has_behavior;  // with/as/enum_string present
 };
 
+// ---------------------------------------------------------------------------
+// schema_opaque — opt-out from recursive type decomposition
+// ---------------------------------------------------------------------------
+
+/// Types marked schema_opaque are treated as opaque by the schema system.
+/// They get kind=unknown and are not recursively decomposed in type_info_instance.
+/// Backend-specific serialize/deserialize hooks handle these types directly.
+template <typename T>
+constexpr inline bool schema_opaque = false;
+
 // ---------------------------------------------------------------------------
 // kind_of<T>() — map C++ types to type_kind values
 // ---------------------------------------------------------------------------
@@ -220,6 +234,10 @@ consteval type_kind kind_of() {
     if constexpr(serde::annotated_type<V>) {
         return kind_of<typename V::annotated_type>();
     }
+    // Opaque types with custom hooks — do not decompose
+    else if constexpr(schema_opaque<V>) {
+        return type_kind::unknown;
+    }
     // Enum -> enumeration
     else if constexpr(std::is_enum_v<V>) {
         return type_kind::enumeration;

include/eventide/serde/schema/field_slot.h

@@ -20,8 +20,8 @@ template <std::size_t I, typename List>
 struct type_list_element;
 
 template <std::size_t I, typename First, typename... Rest>
-struct type_list_element<I, type_list<First, Rest...>>
-    : type_list_element<I - 1, type_list<Rest...>> {};
+struct type_list_element<I, type_list<First, Rest...>> :
+    type_list_element<I - 1, type_list<Rest...>> {};
 
 template <typename First, typename... Rest>
 struct type_list_element<0, type_list<First, Rest...>> {
@@ -60,8 +60,8 @@ struct type_list_concat<List> {
 };
 
 template <typename First, typename Second, typename... Rest>
-struct type_list_concat<First, Second, Rest...>
-    : type_list_concat<type_list_cat_t<First, Second>, Rest...> {};
+struct type_list_concat<First, Second, Rest...> :
+    type_list_concat<type_list_cat_t<First, Second>, Rest...> {};
 
 template <typename... Lists>
 using type_list_concat_t = typename type_list_concat<Lists...>::type;
@@ -72,11 +72,10 @@ template <typename List>
 struct type_list_size;
 
 template <typename... Ts>
-struct type_list_size<type_list<Ts...>>
-    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+struct type_list_size<type_list<Ts...>> : std::integral_constant<std::size_t, sizeof...(Ts)> {};
 
 template <typename List>
-inline constexpr std::size_t type_list_size_v = type_list_size<List>::value;
+constexpr inline std::size_t type_list_size_v = type_list_size<List>::value;
 
 // ---------------------------------------------------------------------------
 // field_slot -- compile-time per-field descriptor
@@ -92,13 +91,11 @@ inline constexpr std::size_t type_list_size_v = type_list_size<List>::value;
 ///                       Defaults to RawType when no behavior attr is present.
 /// @tparam BehaviorAttrs A std::tuple<...> of the behavior attributes found
 ///                       on this field (skip_if, with, as, enum_string, tagged).
-template <typename RawType,
-          typename WireType     = RawType,
-          typename BehaviorAttrs = std::tuple<>>
+template <typename RawType, typename WireType = RawType, typename BehaviorAttrs = std::tuple<>>
 struct field_slot {
-    using raw_type  = RawType;
+    using raw_type = RawType;
     using wire_type = WireType;
-    using attrs     = BehaviorAttrs;
+    using attrs = BehaviorAttrs;
 };
 
 }  // namespace eventide::serde::schema