Attempt the stronger is_standard_layout guard, isolated for CI (#21)

Adds static_assert(std::is_standard_layout<REFLECTABLE>::value, ...)
immediately after the polymorphic guard, as its own commit so a CI failure
on any platform isolates cleanly to this one static_assert.

is_standard_layout on REFLECTABLE is only true if std::wstring and
TimePoint both happen to be standard-layout on the active standard library,
which is implementation-defined. Verified true here on Ubuntu/GCC/libstdc++
in both C++11 and C++20 (matching the issue's own measurement), for all
four representative test records (Person, Pet, Company,
DatetimeContainer). NOT verified in this environment on libc++ (macOS) or
MSVC (Windows) - this sandbox can only build for Linux/GCC.

If CI is green on macOS and Windows (both C++11 and C++20) for this commit,
#21 is fully closed. If it fails on either, revert just this commit,
keeping the polymorphic guard from the prior commit, and note here that the
standard-layout assert is blocked pending #25 (moving the text
representation off std::wstring).

Also adds a mirroring ReflectionTest.ReflectableRecordsAreStandardLayout
runtime test alongside the compile-time check.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NUt3c1wdseRtRSSXfg3MCK

Author: claude

include/reflection.h

@@ -203,6 +203,15 @@ static_assert(!std::is_polymorphic<REFLECTABLE>::value,
               "sqlite-reflection: reflectable records must not be polymorphic "
               "(no virtual functions or virtual/multiple inheritance).");
 
+// Stronger guard, attempted separately from the polymorphic check above: is_standard_layout is
+// only true for REFLECTABLE if std::wstring and sqlite_reflection::TimePoint both happen to be
+// standard-layout on this standard library, which is implementation-defined and unverified here
+// on libc++ (macOS) / MSVC (Windows) - verified true on libstdc++ (Linux). If this line fails to
+// compile on any CI platform, that failure isolates to exactly this static_assert; remove it and
+// keep only the polymorphic guard above (see #21 and #25).
+static_assert(std::is_standard_layout<REFLECTABLE>::value,
+              "sqlite-reflection: reflectable records must be standard-layout.");
+
 /// Provide a static registration function for each reflectable struct
 static std::string CAT(Register, REFLECTABLE)() {
     std::string type_id = typeid(REFLECTABLE).name();

tests/reflection_test.cc

@@ -51,3 +51,14 @@ TEST(ReflectionTest, ReflectableRecordsAreNotPolymorphic) {
     EXPECT_FALSE(std::is_polymorphic<Company>::value);
     EXPECT_FALSE(std::is_polymorphic<DatetimeContainer>::value);
 }
+
+// Mirrors the stronger is_standard_layout static_assert in include/reflection.h (attempted
+// separately from the polymorphic guard, since it's only verified on libstdc++/Linux so far -
+// see #21). If that assert is ever removed because a CI platform can't satisfy it, this test
+// should be removed alongside it rather than weakened to keep passing.
+TEST(ReflectionTest, ReflectableRecordsAreStandardLayout) {
+    EXPECT_TRUE(std::is_standard_layout<Person>::value);
+    EXPECT_TRUE(std::is_standard_layout<Pet>::value);
+    EXPECT_TRUE(std::is_standard_layout<Company>::value);
+    EXPECT_TRUE(std::is_standard_layout<DatetimeContainer>::value);
+}