Remove GdkGLPixelFormat and change how gl contexts are created

The way GdkGLPixelFormat and the framebuffer setup worked matched the
traditional GLX way that GL has worked where you create a native
window and do negotiations for the framebuffer details on that.

This doesn't really match the current model where Gdk owns the
gl rendering and presenting to the toplevel and child widgets work
by using renderbuffers. Additionally, it completely fails on wayland
as there we have to actually allocate the surface buffer for the
toplevel, and there can be only one, with only one framebuffer
config, so we can't expose some API to let the user create different
ones.

So, in the new world we change context creation to:

GdkGLContext *gdk_window_create_gl_context (GdkWindow    *window,
                                            GdkGLProfile  profile,
                                            GError      **error);

Which creates a context for the native window that backs this
particular window, which cannot be bound to another window. The
framebuffer config chosen for the context is the one described by the
window visual (i.e. same bitdept, has alpha if window is rgba visual,
no aux buffers). Anything that requires rendering with other kinds
of buffers (stencil, depth, etc) need to do that with render buffers.

This simplifies the APIs a lot, and allows a sane wayland
implementation. Limiting the context to a single window also fixes
some remaining issues with making contexts current.
Switch to using gdk_gl_context_flush() for page-flip

Rather than hardcoding the bit-blit in end_paint() we call flush.
However, there are some complications:
 * flush using swapbuffers may need to draw more on the back
   buffer than just the current dirty area. So, we let the backend
   add more area to expose.

 * We also keep track of the *actual* update area via activate_update_area.
   So that we can push this as the damaged area for e.g. wayland
   with swap_buffer_with_damage.

 * Since this is pretty complex we make the flush operation non-public.
   This should not be needed anyway, as gdk is in full control of the
   paint loop.

 * Due to the cost of the above we only use GL for drawing a toplevel
   if anything in it is using gl (paint_context is not NULL). The
   env var GDK_ALWAYS_USE_GL overrides this for debugging.

At the moment the gl backends are very naive and repaint everything
each frame, but further work can make this more reasonable.
Implement buffer age optimization to avoid redrawing a lot

This uses the buffer age extension to detect the "age" of the
current backbuffer, to avoid redrawing things that is already
uptodate in the backbuffer. It also adds a new green color
for the update region to show the area of the window that
was redrawn due to having to repaint old areas of the back buffer.
wayland: Use eglSwapBuffersWithDamage

This allows compositors to minimize how much to repaint.
Remove GdkGLContext::swap-interval

We're in full control of the paint loop (and have to be), so the
app should not be meddling with this. We'll set swap-interval if
needed (like e.g. when not running under a compositor, or when
redirected at fullscreen) to always achieve a frame-synced output.
Handle alpha buffers in gdk_cairo_draw_gl_render_buffer

This adds checks for alpha in the software fallback.
Note, this is still a SOURCE operation, so your alpha values
will reach the window, but not blend over other data.
gl: Clean up errors and add UNSUPPORTED_PROFILE error

The new error allows you to fall back properly if not supported.