In gegl_tile_dup(), increate the revision of the newly-created
duplicate tile unconditionally, even if it's empty, so that it gets
stored.
Instead of special-casing empty tiles in the above function, mark
newly-craeted empty tiles as stored in the empty-tile handler.
This way, newly-created empty tiles are not stored, but copied
empty tiles are, since we might need them to replace outdated data
in the tile backend. Tile backends may, in turn, test for empty
tiles upon a SET command, and drop the existing tile instead of
storing the empty tile.
Remove the now-unnecessary revision bump in gegl_buffer_copy().

In gegl_tile_backend_swap_entry_destroy(), when reusing an existing
queued op as an OP_DESTROY, move the op to the top of the queue, so
that the corresponding storage is reclaimed before any pending
WRITE ops. This used to be the behavior before last commit, which
accidentally removed it.

In gegl_tile_backend_swap_entry_destroy(), don't free the entry in
the calling thread when it has a pending op in the queue, but no
allocated storage, since the test for whether the entry has
allocated storage introduces a race condition between the calling
thread and the writer thread, where storage allocation happens.
Instead, always convert the existing op to an OP_DESTROY.
In particular, this could lead to a use-after-free and/or swap-
space leak, if a TILE_SET command is issued for a tile while it is
being written to the swap by the writer thread (after the
corresponding OP_WRITE has been dequeued). In this case, another
OP_WRITE is pushed to the queue. If the corresponding entry
doesn't have storage allocated yet, and is then destroyed, the
entry will be freed while the writer thread is still potentially
using it while serving the earlier OP_WRITE, and the storage
subsequently allocated for it will never be reclaimed.

After commit a5ce7c70b, we no
longer use a sampler in the finite-shadow case, and so we can
process the output in-place in this case too, which allows us to
safely set GeglOperation::want_in_place to TRUE.

For finite shadows, when replacing the current shadow value of a
screen pixel, clear the pixel's now-irrelevant shadow queue, and
correct the active-pixel count. Note that failing to do either of
these doesn't actually produce wrong results, but performance
should be better in some cases now.

Add a gegl:long-shadow operation, which (surprise surprise) creates
a long-shadow effect. The operation supports three shadow styles:
finite, infinite, and fading. The shadow's color, angle, length
(for finite shadows), and midpoint (for fading shadows) are
controllable.
Additionally, the output composition is also controllable, and can
be one of:
- Shadow plus image: Both the shadow and the input image are
included in the output.
- Shadow only: Only the shadow is included in the output.
- Shadow minus image: Only the parts of the shadow that aren't
obscured by the input image are included in the input. In
GIMP, such output can be combined with the original layer using
"Merge" layer mode, to achieve the same result as "Shadow plus
image", using separate layers for the image and the shadow.
The operation preserves partial-transparency, and produces anti-
aliased results.

Add an "abyss-policy" property to gegl:median-blur, which controls
the input's abyss policy, and can be one of NONE or CLAMP, for now.
When the abyss policy is NONE, the op's bounding box is expanded
according to the blur radius, while when the abyss policy is CLAMP,
the op's bounding box is clamped to the input bounding box.
The default abyss policy is CLAMP, to keep the current behavior.

Annotate all directional angle properties with a "direction" UI-
meta, specifying whether the angle is measured clockwise ("cw") or
counter-clockwise ("ccw"). This allows directionality-dependent
UI, such as GIMP's dial widget, to use the correct direction.