[Feat] (MG_State, MG_Impl, MG_Backend): let a bound program pipeline actually draw

The pipeline object bookkeeping landed already - names, stage slots, queries -
but nothing consumed it. Every draw asked the context for the current program,
got null because a pipeline is used with program zero, and drew nothing;
glCreateShaderProgramv was still a stub returning zero, so
direct_state_access.program_pipelines_functional could not even build its stage
programs and reported InternalError on both backends.

glCreateShaderProgramv is written as the exact call sequence the spec defines it
to be, with one deviation that matters: the link goes straight to
ProgramObject::Link(false) rather than through LinkProgram, because LinkProgram
injects a default fragment shader into a program that has none - correct for a
whole program, wrong for a separable vertex-stage one whose fragment stage comes
from the pipeline. glDetachShader defers removal to the next link, so the program
keeps the shader object it was built from while correctly no longer reporting it
attached. GL_PROGRAM_SEPARABLE joins glProgramParameteri and glGetProgramiv.

Everything downstream of a draw - both backends, the uniform plumbing, the draw
validation - is written against one linked program, so rather than teach all of
it about stages, the pipeline is flattened: GetProgramForDraw() composites the
stage programs' shaders into a single hidden program object and caches it against
a signature of each stage program's lifetime id and link generation, so it is
rebuilt exactly when a stage or a stage's link changes. The composite carries no
GL name - it must not answer glIsProgram, and it must not consume a name the
application could be handed.

Uniform entry points get their own resolver rather than sharing that one:
glUniform* addresses the pipeline's active program, not the composited draw
program. GL_CURRENT_PROGRAM still reads the program in use, which is zero here.

Fixes program_pipelines_functional on both backends.

MobileGL/MG_State/GLState/Core.cpp

@@ -343,6 +343,55 @@ namespace MobileGL::MG_State {
             return m_programState.GetCurrentProgram();
         }
 
+        const SharedPtr<ProgramObject>& GLContext::GetProgramForDraw() {
+            static const SharedPtr<ProgramObject> nullProgram = nullptr;
+            const auto& currentProgram = m_programState.GetCurrentProgram();
+            if (currentProgram) return currentProgram;
+            if (m_boundProgramPipeline == 0) return nullProgram;
+            const auto& pipeline = GetBoundProgramPipeline();
+            if (!pipeline) return nullProgram;
+
+            const auto signature = pipeline->ComputeDrawProgramSignature();
+            if (const auto& cached = pipeline->GetCachedDrawProgram(signature)) return cached;
+
+            // Everything downstream of here - the backends, the uniform plumbing, the draw
+            // validation - is written against a single linked program, so the pipeline is
+            // flattened into one. Each stage contributes only the shaders that serve it, so a
+            // program bound to two stages is not pulled in twice and a program bound to a
+            // stage it does not implement contributes nothing.
+            // Deliberately not a named program: it is reachable only through the pipeline, it
+            // must not answer glIsProgram, and it must not consume a name the application
+            // could otherwise be handed. Backend registries key on the object, not the name.
+            auto composite = MakeShared<ProgramObject>(0u);
+
+            Bool anyStage = false;
+            for (SizeT stage = 0; stage < static_cast<SizeT>(ShaderStage::ShaderStageCount); ++stage) {
+                const auto& stageProgram = pipeline->GetStageProgram(static_cast<ShaderStage>(stage));
+                if (!stageProgram) continue;
+                for (const auto& shader : stageProgram->GetAttachedShaders()) {
+                    if (!shader || static_cast<SizeT>(shader->GetShaderStage()) != stage) continue;
+                    composite->AttachShader(shader);
+                    anyStage = true;
+                }
+            }
+            if (!anyStage) return nullProgram;
+            // A pipeline with no fragment stage still rasterises, so the default fragment
+            // shader is wanted here even though the separable stage programs never get one.
+            composite->Link(true);
+            pipeline->SetCachedDrawProgram(signature, Move(composite));
+            return pipeline->GetCachedDrawProgram(signature);
+        }
+
+        const SharedPtr<ProgramObject>& GLContext::GetProgramForUniform() {
+            const auto& currentProgram = m_programState.GetCurrentProgram();
+            if (currentProgram) return currentProgram;
+            static const SharedPtr<ProgramObject> nullProgram = nullptr;
+            if (m_boundProgramPipeline == 0) return nullProgram;
+            const auto& pipeline = GetBoundProgramPipeline();
+            if (!pipeline) return nullProgram;
+            return pipeline->GetActiveProgram();
+        }
+
         // RenderState
         Uint GLContext::GetRenderStateParametersVersion() const {
             return m_renderState.GetVersion();