fix: MSVC compiler compatibility in consteval name-extraction functions

column_field.hpp (tag_to_column_name):
- Add MSVC-specific end delimiters: MSVC __FUNCSIG__ closes the template
  argument with '>' (e.g. tag_to_column_name<struct 'anonymous'::tag>)
  rather than ';'/'_tag]' used in GCC/Clang __PRETTY_FUNCTION__.
  Without this, both end1 and end2 are npos and the static_assert fires.

schema_generator.hpp (extract_type_name):
- Rewrite to use constexpr local variables and ternary expressions in
  place of if/else chains. In a consteval function MSVC instantiates
  per-type, making each find() result a known compile-time constant;
  comparing those against npos in a regular 'if' triggers warning C4127
  ('conditional expression is constant') which /WX promotes to an error.
  Switching to constexpr + ternary eliminates all C4127 warnings.
- Also convert marker_pos/start/end to constexpr so if constexpr can
  guard the npos fallback path cleanly.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Pierre-Luc Gagné

lib/include/ds_mysql/column_field.hpp

@@ -61,8 +61,15 @@ consteval std::string_view tag_to_column_name() noexcept {
         return {};
     }
     constexpr auto start = key_pos + key.size();
+#if defined(_MSC_VER)
+    // MSVC __FUNCSIG__: "...tag_to_column_name<struct `anonymous-namespace'::tag>(void)..."
+    // The tag type ends at '>' (template arg close); '(' is a secondary fallback.
+    constexpr auto end1 = sig.find('>', start);
+    constexpr auto end2 = sig.find('(', start);
+#else
     constexpr auto end1 = sig.find(';', start);
     constexpr auto end2 = sig.find(']', start);
+#endif
     constexpr auto end = (end1 != npos && end2 != npos) ? ((end1 < end2) ? end1 : end2) :
                          (end1 != npos) ? end1 :
                          (end2 != npos) ? end2 : npos;

lib/include/ds_mysql/schema_generator.hpp

@@ -185,43 +185,34 @@ consteval std::string_view extract_type_name() {
     return "unknown";
 #endif
 
-    auto const marker_pos = signature.find(marker);
-    if (marker_pos == std::string_view::npos) {
+    constexpr auto npos = std::string_view::npos;
+    constexpr auto marker_pos = signature.find(marker);
+    if constexpr (marker_pos == npos) {
         return "unknown";
     }
 
-    auto const start = marker_pos + marker.size();
+    constexpr auto start = marker_pos + marker.size();
 
 #if defined(__clang__) || defined(__GNUC__)
     // GCC/Clang format: [with T = TYPE] or [with T = TYPE; ALIAS = EXPANSION, ...]
-    // Neither ';' nor ']' can appear in a C++ type name, making them safe end delimiters.
-    auto const end_semicolon = signature.find(';', start);
-    auto const end_bracket = signature.find(']', start);
-
-    auto end = std::string_view::npos;
-    if (end_semicolon != std::string_view::npos && end_bracket != std::string_view::npos) {
-        end = end_semicolon < end_bracket ? end_semicolon : end_bracket;
-    } else if (end_semicolon != std::string_view::npos) {
-        end = end_semicolon;
-    } else if (end_bracket != std::string_view::npos) {
-        end = end_bracket;
-    }
+    constexpr auto end_semicolon = signature.find(';', start);
+    constexpr auto end_bracket   = signature.find(']', start);
+    constexpr auto end = (end_semicolon != npos && end_bracket != npos)
+                             ? (end_semicolon < end_bracket ? end_semicolon : end_bracket)
+                         : (end_semicolon != npos ? end_semicolon
+                          : end_bracket != npos   ? end_bracket : npos);
 #else
-    // MSVC format: extract_type_name<TYPE>
-    auto const end_bracket = signature.find('>', start);
-    auto const end_comma = signature.find(',', start);
-
-    auto end = std::string_view::npos;
-    if (end_bracket != std::string_view::npos && end_comma != std::string_view::npos) {
-        end = end_bracket < end_comma ? end_bracket : end_comma;
-    } else if (end_bracket != std::string_view::npos) {
-        end = end_bracket;
-    } else if (end_comma != std::string_view::npos) {
-        end = end_comma;
-    }
+    // MSVC format: "...extract_type_name<TYPE>(void)..."
+    // The type ends at '>' (template arg close) or ',' (comma in multi-param templates).
+    constexpr auto end_bracket = signature.find('>', start);
+    constexpr auto end_comma   = signature.find(',', start);
+    constexpr auto end = (end_bracket != npos && end_comma != npos)
+                             ? (end_bracket < end_comma ? end_bracket : end_comma)
+                         : (end_bracket != npos ? end_bracket
+                          : end_comma != npos   ? end_comma : npos);
 #endif
 
-    if (end == std::string_view::npos || end <= start) {
+    if constexpr (end == npos || end <= start) {
         return "unknown";
     }