Make FlCompositorOpenGL and FlCompositorSoftware derive directly from
GObject and expose their present_layers, get_frame_size and render
functions as public concrete functions. The view renderers and
compositor tests now call these directly, removing the need for the
FlCompositor base class, which is deleted.

Make FlCompositorSoftware pure frame storage/combining by moving the
frame_mutex and task_runner into FlViewRendererSoftware. The renderer now
owns the synchronization: it locks around compositor access, signals the
task runner after presenting, and runs the resize wait loop in draw.

Make FlCompositorOpenGL pure frame storage/combining by moving the
frame_mutex and task_runner into FlViewRendererOpenGL. The renderer now
owns the synchronization: it locks around compositor access, signals the
task runner after presenting, and runs the resize wait loop in draw.

The pixels buffer is only populated when shareable is FALSE, not TRUE.

Introduce an empty FlViewRenderer subclass for rendering OpenGL into a Wayland
subsurface, selected when the OpenGL backend is used on a Wayland display. The
renderer implementation will be added in a later stage.

Render Flutter OpenGL frames into a Wayland subsurface by compositing
layers into the engine's shareable framebuffer, then blitting the
composited frame to a wl_egl_window EGL surface and swapping. Adds
wayland-client/wayland-egl configs and an accessor to retrieve the
compositor framebuffer.

Match the FlViewRendererOpenGL and FlViewRendererSoftware convention of
clearing the frame and resize mutexes in dispose() while leaving the
compositor release in finalize().

Switching the EGL context on the engine's raster thread inside
present_layers corrupted the Impeller GLES backend's cached context
state, causing a fatal GL_INVALID_FRAMEBUFFER_OPERATION on glClear.
Composite on the raster thread as before, but perform the EGL blit and
swap to the subsurface on the GTK thread in draw(), where it never
touches the engine's rendering context. Also stop terminating the EGL
display in unrealize, since it is shared with the engine.

Move the Wayland registry binding and wl_compositor/wl_subcompositor/
wl_surface/wl_subsurface management out of FlViewRendererSubsurface and
into a dedicated FlSubsurface module, mirroring flutter_subsurface.c in
the prototype. The renderer now creates an FlSubsurface and uses it to
obtain the wl_surface for its EGL window and to reposition the
subsurface.

Destroying an FlFramebuffer makes OpenGL calls (glDeleteFramebuffers
etc.) that epoxy resolves lazily and which require a current context.
The sibling was held in a g_autoptr and therefore destroyed at scope
exit, after the EGL context had already been cleared, tripping epoxy's
"Couldn't find current GLX or EGL context" assertion. Release it
explicitly while the context is still current.

The resize barrier (ported from the prototype's flutter_view_resize)
blocked the GTK main thread in size_allocate on a plain GCond until the
raster thread presented a frame of the new size. Unlike the OpenGL
renderer's fl_task_runner_wait, this wait did not pump the platform task
runner, so it could deadlock frame production and lock up resizing.

A Wayland subsurface commits its own buffer independently of the parent
surface, so no such synchronization is needed: drop the barrier and the
now-unused task runner, and just resize the wl_egl_window.

A wl_surface has an infinite input region by default, so the subsurface
placed over the view captured pointer, touch and keyboard events instead
of letting them reach the parent GTK surface, breaking all input. Set an
empty input region on the subsurface so events pass through to GTK, which
handles input for the view.

Add a method on the FlViewRenderer base class to emit the "first-frame"
signal, so subclasses no longer emit it by name directly. Update the
OpenGL, software and subsurface renderers to use it.

The subsurface renderer created its own EGL context unshared with the
engine and relied on EGLImage (via fl_framebuffer_create_sibling) to
access the engine's composited frame. This required EGLImage support.

Create the subsurface's EGL context sharing the engine's render context
so the engine frame texture can be read directly. The compositor's frame
sharing strategy is now an explicit enum (EGL image, shared context, or
CPU copy); the shared-context mode creates a framebuffer with no EGLImage
and skips the CPU readback.

The EGL config is only used while setting up the EGL context and window
surface, so it does not need to be stored on the renderer.

The EGL display is owned by the engine's FlOpenGLManager, not the
renderer. Rather than caching a copy, fetch it through a get_egl_display
helper where needed. This removes duplicated, borrowed state and makes
it clear the renderer does not own the display.

The background color storage, default, set_background_color and the
paint-background logic were duplicated in each renderer backend. Move
them into the FlViewRenderer base class: it now stores the color in
private instance data, exposes fl_view_renderer_paint_background, and
implements set_background_color directly (the per-subclass vfunc is
removed). Subclasses call fl_view_renderer_paint_background in their
draw implementation.