[Feat] (MG_Impl, MG_State, MG_Backend, MG_Util): packed 2_10_10_10 and GL_BGRA vertex array formats

glVertexAttribPointer now accepts the GL 3.3 Core packed types
GL_INT_/GL_UNSIGNED_INT_2_10_10_10_REV and the GL_BGRA size, clearing the
two long-standing "// TODO: implement GL_BGRA support" markers. Adds the
format end to end across the frontend, VAO state, and both backends.

- DataType: add Int2101010Rev / Uint2101010Rev with GLToMG / MGToGL /
  MGToStr converter cases.
- Validation (ValidateVertexAttribFormat): the full glVertexAttribPointer /
  glVertexAttribIPointer error table -- size is 1..4 or GL_BGRA (else
  INVALID_VALUE, which takes precedence); a packed type requires size 4 or
  GL_BGRA (else INVALID_OPERATION); GL_BGRA requires GL_UNSIGNED_BYTE or a
  packed type AND normalized == GL_TRUE (else INVALID_OPERATION); the
  integer path rejects packed types (INVALID_ENUM) and GL_BGRA size
  (INVALID_VALUE).
- VAO: store GL_BGRA as size 4 plus a new IsBgra flag (reset on the
  binding-format path).
- DirectVulkan: map the packed/BGRA formats to
  VK_FORMAT_A2B10G10R10_* (normal) and VK_FORMAT_A2R10G10B10_* /
  VK_FORMAT_B8G8R8A8_UNORM (BGRA reversed), fold IsBgra into the pipeline
  hash, and size packed/BGRA elements as one 4-byte word via
  GetAttributeByteSize. (Vulkan *_SNORM decodes with the GL 4.2 symmetric
  rule, a documented deviation from the 3.3 signed formula.)
- DirectGLES: round-trip the packed enum through the loader, pass GL_BGRA
  as the driver size argument, and size client uploads with the packed
  4-byte word.

Tests: 4 VertexArrayTest cases covering packed/BGRA storage and the full
float/integer error table; the packed-size hard-fail is mutation-verified.
VertexArrayTest 42/42, SanityTest 30/30, library builds clean.

MobileGL/MG_Backend/DirectGLES/Managers.cpp

@@ -572,6 +572,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     return 0;
                 }
             }
+
+            // Tightly-packed byte size of one vertex element: 4 for the 2_10_10_10 types and GL_BGRA
+            // (one 32-bit word / 4 bytes), componentSize * size otherwise. 0 for unknown types.
+            SizeT GetAttributeByteSize(DataType type, int size, Bool isBgra) {
+                if (type == DataType::Int2101010Rev || type == DataType::Uint2101010Rev || isBgra) {
+                    return 4;
+                }
+                const SizeT componentSize = GetDataTypeSize(type);
+                return componentSize == 0 ? 0 : componentSize * static_cast<SizeT>(size);
+            }
         } // namespace
 
         BackendVertexArrayObject::BackendVertexArrayObject() {
@@ -665,8 +675,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 if (!attrib.IsInteger) {
+                    // GL_BGRA is passed to the driver as the size argument (the driver reorders BGRA).
+                    const GLint glSize = attrib.IsBgra ? static_cast<GLint>(GL_BGRA) : attrib.Size;
                     g_GLESFuncs.glVertexAttribPointer(
-                        attribIndex, attrib.Size, MG_Util::ConvertDataTypeToGLEnum(attrib.Type),
+                        attribIndex, glSize, MG_Util::ConvertDataTypeToGLEnum(attrib.Type),
                         attrib.Normalized ? GL_TRUE : GL_FALSE, attrib.Stride, (const void*)attrib.Offset);
                 } else {
                     g_GLESFuncs.glVertexAttribIPointer(attribIndex, attrib.Size,
@@ -720,12 +732,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 const auto* clientData = reinterpret_cast<const Uint8*>(attrib.Offset);
-                const SizeT componentSize = GetDataTypeSize(attrib.Type);
-                if (!clientData || componentSize == 0 || attrib.Size <= 0) {
+                const SizeT elementSize = GetAttributeByteSize(attrib.Type, attrib.Size, attrib.IsBgra);
+                if (!clientData || elementSize == 0 || attrib.Size <= 0) {
                     continue;
                 }
 
-                const SizeT elementSize = componentSize * static_cast<SizeT>(attrib.Size);
                 const SizeT stride = attrib.Stride > 0 ? static_cast<SizeT>(attrib.Stride) : elementSize;
                 const SizeT uploadSize = static_cast<SizeT>(first + count - 1) * stride + elementSize;
 
@@ -743,8 +754,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                          GL_STREAM_DRAW);
 
                 if (!attrib.IsInteger) {
+                    const GLint glSize = attrib.IsBgra ? static_cast<GLint>(GL_BGRA) : attrib.Size;
                     g_GLESFuncs.glVertexAttribPointer(
-                        attribIndex, attrib.Size, MG_Util::ConvertDataTypeToGLEnum(attrib.Type),
+                        attribIndex, glSize, MG_Util::ConvertDataTypeToGLEnum(attrib.Type),
                         attrib.Normalized ? GL_TRUE : GL_FALSE, static_cast<GLsizei>(stride), nullptr);
                 } else {
                     g_GLESFuncs.glVertexAttribIPointer(attribIndex, attrib.Size,