Teach Markdown printer about @mapping and @command

Add @mapping support to Vim printer

Get @command annotation working

Make wrapping aware of concealed characters

This is the cheap-but-approximate approach. Results are reasonable, costs are
very low, and the consequences of being (slightly) wrong are livable. Let's go
with this for now.

Kill a stray comment

Use worktree as issue tracker

Taking standards to new lows.

Fix misplaced whitespace in output

Add test showing @option output

Something buggy in the parser: note that we have to explicitly say "none" for
the no-default case, but I intended that to be simply omittable.

Print options

Alignment will need a bit of work here, but this is a good first draft.

Specifically, if we want things to look like this in the UI:

                                g:SomeOpt
    g:SomeOpt        string (default: 10)

The output will actually need to be:

                                *g:SomeOpt*
    |g:SomeOpt|        string (default: 10)

Because `|` and `*` don't take up any width due to being concealed by Vim.

Fix lints

Use actual max int rather than hard-coded constant

Handle overlength headings

#uglycode

Fix duplicate content

Initial cut at @mapping, @command, @option, @function

Still some bugs to sort out (eg. duplicate symbol table entry due to extra
`MappingsAnnotation` when we perform extraction) and polish to apply (not
actually printing the options/functions etc).

Make Vim headings work by colocating link targets on same line

Add entries to symbol table for generated headings

Autogen headings in Vim printer too

Add auto-generated headings to Markdown printer

For @functions, @commands, @mappings, @options.

Add basic support for @options, @functions and @commands annotations

Still need to auto-emit headings for these, but I think they basically work.
Also need to make `Option`, `Function` and `Command` visitors.

Overhaul testing and compilation

We now "compile" in the test suite, meaning that we pipe our translation units
through the various extraction transforms after parsing. This means three main
things:

- Everything is nested inside a `Project` node type now, consisting of one or
  more translation units.
- Nodes within the project are ordered (or reordered) to maintain desired
  section ordering.
- As we add more phases to "compilation" (eg. automated insertion of table
  of contents etc), these will get reflected in the test suite automatically.

As part of this, extracted test-specific bits out into a new `Util` module (ie.
pretty-printing methods, convenience functions) and the "compile" pipeline into
a `Compile` module.

Add a missing type annotation

Don't rely on transformers

Don't want two monad transformer libraries at play here
needlessly.

Kill off an out-of-date comment

Fix copy pasta error

Suprised neither the compiler nor the tests seemed to
complain about this.

DRY up other visitors

More simplification

Trim down imports

More DRYing

Further visitor DRYing

Tidy indentation

Fix lints

Extract Visitor module

First step in factoring out some of the duplication here.

Remove some old comments

Fix indentation

Suppress unwanted trailing whitespace

Further refine hard-wrapping

Be better about hard-wrap placement

Still needs a refactor, but the output is better.

Rename `hardwrap` -> `textwidth`

Because I want to use the name `hardwrap` for a function as part of some
imminent refactoring.

Align

Always link unconditionally in Vim help output

May not even need the symbol table at all in this printer, but we'll keep it
around for now, just in case.

Replace a literal that I missed with a constant

Move hardwrapping from `plaintext` into `append`

Solves a bunch of issues, creates others, which I will have to fix in a
follow-up. The code itself is a complex, fragile, ugly, clusterfuck, so consider
this a work-in-progress.

Additionally, there are some unfortunate breaks which were there before and
continue to be there, like just inside parens, and things like that. Will need
to sort all that out too.

Tidy

Get rid of meaningless distinction in Markdown printer

All the cases must return Env, so let's put them all together
whether or not they explicitly access the state.

Share integration tests inputs across output types

May eventually share other things too (I still have some
manual symlinks going on), but this is a good start.

Make slurping a little more robust

But note remaining caveat inline. This really
should only be used to trim whitespace, at least
for now.

Remove unwanted blank lines before fenced code blocks

But note that this is a little bit fragile, even though
the tests pass. More work can be done to make this more
robust.

Fix some lints

Reorder things

Eliminate unwanted trailing whitespace

Initial primitive cut at hard wrapping

This isn't ideal as noted inline (no rollback yet, which means we wind up with
trailing whitespace), but it is a reasonable start.

Remove last use of Append

Convert one more `Append`

Continue `Append` -> `append` conversion

Update `fenced` to use `append`

I wanted to write this using `>>=` but evidently that is not the right tool.

Inline `return` call inside `fenced` function

Step 1 of ?.

Drop excess blank lines after fenced code blocks in Vim output

Create append helper and start using it

Feel the linter love

Get some TODOs out of the work tree

Horrible hygiene I know, but I need to compensate the functional purity somehow.

Add partial line to Vim printer context

This will be used to perform current line width calculations, so that we can
decide whether or not to hard-wrap.

Use operations list in Vim printer

Let's see if I can use this to implement hard-wrapping. It is very ugly, but if
I can get it working I'll have some tests in place and can then try refactoring.

Deal with linebreaks inside list items

Fix unwanted stripping of leading whitespace

Stripping trailing whitespace is desired, but the leading
strip was actually busting the output.

Fix excess line at break tags in blockquotes

Add some tests

Revealing some still-unresolved issues to be fixed.

Show how linebreaks can be contextual

Further flesh out README

Even sillier example of putting monadic state

Silly demonstration of getting at monadic state

Doesn't affect the output, but proves that I can `get` the state.

Use State + Reader monad transformer stack

Doesn't do anything useful yet, but it will: I want to use this to track current
line width, for the purposes of wrapping. As noted here:

https://ro-che.info/articles/2012-01-02-composing-monads

The order in which I compose the State and Reader monad transformers shouldn't
matter at all. If I end up needing Writer too, I will be able to replace this
with the RWS monad transformer.

Add some fixture files that I previously forgot to include

Fix indentation

Rename `State` to `Metadata`

State was a terrible name to use in conjunction with the Reader monad, as it
easily leads to confusion with the State monad. Let's just call it `Metadata`
(about the project AST) for now; that's a horribly generic name too, but it is
at least an improvement.

Update .tmux paths for Vim 8-pre

Fix lint

Upgrade README

Hook up plugin and footer extraction

Obviously the horrible `ast2` binding name will have to go away, but this works.

Extract footers and plugin sections

Fix trailing whitespace at end of file

Actually write output files

Simplify some case statements with the LambdaCase extension

Via:

  https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/basic-syntax-extensions

Use MultiWayIf extension to make a nested `if` less ugly

Still pretty ugly though...

Via:

  https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/basic-syntax-extensions

Sort link targets for Markdown output too

Sort link targets

Right-align link targets

Start prepping to hangle hard-wrapping

This is going to be ugly...

Fix @plugin printing in Vim printer

Make Vim printer more useful

Still a work-in-progress, but it is close to what we want now.

Fix some lints

Fix test breakage caused by missing modules

Add Mappings visitor

Add extract function to Plugin visitor

Lots of duplication/similarity with the Footer visitor, but I want to do this a
few times before I dry to identify and abstract away the pattern.

Trim down footer extraction to its "final" form

Want the external interface provided by "extract" to
be simple, so we wrap the `runWriter` call and return
a List instead of a DList.

Add some notes about footer extraction

Likely going to settle on postorder uniplate technique
at which point I will remove some of the extraneous
exports and simplify.

Teach CLI to operate on target arguments

Still not writing to filesystem, but will add that in a bit.
For now, just debugging everything over standard out is
super convenient.

Obviously, this code is super ugly with that staggered `if`
statement, so will refactor.

Make CLI tool print markdown

Apologies for the shitty commit with a bunch of very stale lingering worktree
changes just thrown in there for no good reason.

Include a couple of examples of alternatives to `walk`

Fix lints

Remove explicit Plated instance

Thought I would need it based on reading:

  https://hackage.haskell.org/package/lens-4.13.2.1/docs/Control-Lens-Plated.html

but it seems that I do not.