Types: Add `instance Applicative Private`
Rename Ganeti.Utils.MonadPlus to Ganeti.Utils.Monad.

It contains only one MonadPlus-specific function and we would like
to add more Monad-specific functions.
Auto-derive instances where possible

Removes a lot of unnecessary code.
Utils.Monad: Add anyM and allM

Useful for short-circuiting computations.
Query.Filter: Simplify `evaluateFilter`

We can remove the special-casing using `anyM` and `allM`.
Query.Language: Add Ord instances

We need them for putting things into Sets and Maps.
Add MonadBaseControl instance for RpcClientMonad

So that exceptions can be caught in the `RpcClientMonad`.
Utils: Add `isUUID`

We have an existing uuidRegex with which UUIDs can be checked,
but it is conditionally compiled if Ganeti is configured with
regex-pcre support, and we don't want to make the dependency on that
unconditional.

This implements `isUUID` with an Attoparsec parser that is equivalent
to the `uuidRegex`.
WConfd.Client: Add `withLockedConfig` helper function

Blocks until a a lock on the config is obtained.
Query.Server: Extract `handleQuery` from `handleClassicQuery`
JSON: Add Tuple5 type

This is because Text.JSON from the "json" package only has JSON
instances for tuples up to size 4.
WIP: Add filter management to Luxid, add RAPI and CLI interfaces
ReasonRateLimiting: Generalize `slotMapFromJob` a bit

This function doesn't need to take a `JobWithStat`, the `QueuedJob`
inside it is sufficient.
ReasonRateLimiting: Refactor: Extract `queueSlotMap` function

Makes `reasonRateLimit` easier to read.
Generalize SlotMap

This turns the existing `SlotMap` from the structure

  Map (label :: String, limit :: Int) (occupied :: Int)

into

  Map (label :: a) (occupied :: Int, limit :: Int)

and extracts it into its own module; this makes it possible to use
`SlotMap`s for cases outside of reason rate limiting.

There is also a semantic clean-up (not affecting how reason rate limiting
works): `joinSlotMap` (now `occupySlots`) no longer takes a `SlotMap`
as second argument, removing the need to decide how the limits of the
second `SlotMap` affect the return value.

Before `c = joinSlotMap a b`  allowed to have keys in `b` that don't appear
in `a`, and those would appear in `c` with the limits from `b` (so `a` does
not constrain them).
In the new `occupySlots`, such keys have a limit of 0 instead.
Cabal: Ganeti.Utils.MonadPlus -> Ganeti.Utils.Monad
Query.Filter: Simplify `wrapGetter`

No need to pass the unmodified QffMode `qff` supplied by the caller
unmodified to a function supplied by the caller.
Query.Filter: Add evaluateFilterM

This is a more general version of evaluateFilter, which can be
used for general evaluations of the Ganeti filter language that
do not involve ConfigData, live data and other specialties.

To make this function general enough for expressing very specific
evaluations (such as expressing `evaluateFilter`, which has various
short-cuts, in terms of `evaluateFilterM`), a GADT is introduced
that captures the operations we can perform on the leaves of the
query language.

This lack of separation between the recursive structure and the leaf
structure is what made it hard to write generic functions on `Filter`.

However, we currently need this separation only for filter evaluation
functions and not in the type of `Filter` itself, so
Ganeti.Query.Language remains unchanged.
Query.Filter: Simplify `evaluateFilter`

We can now express it in terms of `evaluateFilterM`.
Query.Filter: `evaluateFilter` -> `evaluateQueryFilter`

This captures better what it does, and doesn't give the impression
that it is a pure version of `evaluateFilterM`.