(also got rid of the map templater, which had version problems with
mustache — it's not likely anyone will need it anyways)

this removes:
 - the bbb properties
 - all explicit mentions of rc3
 - the weird script domain hacks (done via a substitution now)
 - some (few) of the weirder code choices

it also adds some more type level witchery to deal with configs, which
for some reason seems to be the hardest problem of this entire program …

also the server now does inter-assembly dependency checking!

also don't keep adjusted maps around if not necessary

(instead, `walint --version` will now just say "unknown")

as annoying as yaml is, cabal's package format is somehow worse, apparently

If --version is given, `walint` prints version information, then exists
with code 0.

(and no one's documented that)

Anyways it now uses utf8 which seems a little more reasonable.

Among them
 - always set correct exit codes
 - refuse to write out files if the out path already exists
 - calculate the overall severity correctly
 - slightly changed the json output schema
 - also output the text output format in json
 - make the default config.json suitable for a production environment

(didn't do anything, and it seems better to do all of these things in
the config anyways)

also yet another typeclass™, because why not?

This got kinda out of hand, but it can now (a) read a json config file
and (b) patch that with another json given on the command line to change
some of the options given in the file.

No, I probably didn't need to make the `patch` function sufficiently
general to work with arbitrary records, but it was kinda fun to do.

(but not (yet?) on missing maps/entrypoints)

this also includes some more monad plumbing, and an option for the
linter to actually write things out again. Some of the previous commit
was reverted a bit since it turned out to be stupid, but overall it was
suprisingly easy once I got around to it, so yay! i guess

Also includes a fairly silly example of how to use it.

also, configurable log level, which only required relaxing the type
system once!

(+ checking that paths don't run outside of respositories)

Adds a PrettyPrint typeclass which operates on Text and should replace
Show, since constantly converting strings from linked lists to arrays
seems somewhat silly.

This makes map loading (and parsing) part of the linter, and also makes
it return "general lints" and nothing else in case that failed.

Possibly a sum type would be nicer here, but I guess it's not really
important since everything ends up as json anyways?

input options are mostly dummies for now, but some work (e.g. --inpath
and --json). Lints can now be optionally printed as json to be
reasonably machine-readable (and the json can be pretty-printed to make
it human-readable again …).

(also renaming things now that concepts seem a bit clearer)

Lots of monads everywhere, hurray!

(unfortunately, workadventure maps don't quite form a category; they lack composition …)

Credits:
 - the example.json file is by TabascoEye (with some modifications for testing purposes)
 - the Tiled module is forked from aeson-tiled on hackage, since that package didn't
   handle custom layer properties correctly