seat: Move pointer event handling to MetaWaylandPointer as well

Now everything that deals with the pointer is inside meta-wayland-pointer.c
seat: Don't set the data device key focus on get_keyboard creation

It's not necessary, as we don't use anything from the protocol
keyboard at all.
seat: Move the keyboard resource creation over to MetaWaylandKeyboard
display: Kill #if 0'd support for _NET_RESTACK_WINDOW requests

The code has been dead and broken for a long, long time now.
pointer/keyboard: Rearrange slightly
pointer: Remove unused field
pointer: Remove our own position tracking

Use the coords inside ClutterInputDevice instead.
wayland: Make subsurfaces reactive
wayland-surface: Merge actor_surface_commit back in

Since we do it unconditionally now, the code flows better
if it's inline with commit_double_buffered_state.
wayland: Rename DoubleBufferedState to PendingState

I was talking with other people and they became confused at the
term "double-buffered", since we were also talking about
double-buffering in general, e.g. swapping between two buffers.

Instead, we'll adapt the "pending state" nomenclature that we
already use for the field / variable names.
wayland: Remove an extraneous variable
wayland: Rename pending_surface_state => pending

This matches what's normally done.
wayland-surface: Simplify move_double_buffered_state

The majority of the data we can simply copy from one to the other.
wayland-surface: Fix offset with window dragging

The grab_x / grab_y here were converted from fixed integers to
floats, but we forgot to update one place in the code that used
them as fixed integers.
pointer: Reindent
pointer: Unset the window cursor when we do a pick

... not when we do an update.

We only repick when we handle events, not when we update. Perhaps
this is a mistake.

Since update runs before handle_event, this means that when we
drop a grab, update will notice the NULL surface, since we haven't
repicked after the event, and then we'll repick the correct surface.
The end result is that you see a root cursor after a grab ends,
rather than the correct window cursor.

This doesn't fix it, since the current surface becomes NULL when
we start the grab. But it does make the code here more correct when
we fix that bug.
pointer: Merge update_current_focus and repick_for_event

In order to correctly fix the issue to make sure we only set the
focused surface to NULL during a grab, but not the current surface,
we need to merge update_current_surface back into repick_for_event
so we have more control over the behavior here.
pointer: Clean up repick_for_event a bit
pointer: Only the focus_surface should only be influenced by the grab

... not the normal current. That should *always* be the surface under
the pointer, regardless of events.
pointer: Split out the code that sets the focus surface