At this point the pipeline for the default "suggest" task has been
modified to include an Autocorrect step. That's all hooked up, and a
callback for `autocorrect/1` has been added to the `Credo.Check`
behaviour and the default implementation. This can be implemented for
each check individually, and it's a noop for now.

At this point the task in the execution pipeline for running the
autocorrect is implemented & tested. It's naive, but it should work in
basic cases!

At this point we have autocorrect functionality implemented & working
for the TrailingBlankLine check. I've verified this with manual testing.
The UX still has a ton of work to do, but for now the bulk of the work
is actually working.

We can now pass an `--autocorrect` flag to the default `suggest` command
when running `mix credo` and it works!

Now when we autocorrect an issue, we remove that issue from the stored
list of issues so it isn't shown to the user (since technically it's no
longer an issue since it was autocorrected).

One other thing we might do is to change the formatter to display when
an issue was there and to indicate that it was autocorrected, also
making sure the exit code is 0 for any autocorrected issues, but for now
this seemed like a reasonable path forward and much simpler than this
option.

At this point it will autocorrect the most basic version of alias
ordering, but it doesn't yet handle multi-aliases or handle groupings of
aliases. That will come in a later commit.

More basics of the autocorrect behavior for the alias ordering check
have been implemented, and now we just need to handle blocks of aliases
with whitespace between them.

We've now handled pretty much all the use cases for ordering aliases
automatically. There is some formatter whackiness that will need to be
figured out, but beyond that this is a good example of how an
autocorrect callback might be implemented for a more involved check than
the first one.

This is the first implementation of an autocorrect callback for a
consistency check. I don't _love_ how we're doing it right now since
we're not actually storing the state of what the "correct" behavior is
that should be changed to, so instead we're just using the issue message
to give us information about what the autocorrect behavior should be.
It's not great, but it works!

This autocorrects an unless with else check so that we're changing it to
an `if` statement.

This adds the first bits of an implementation for how we might want to
autocorrect an unused String operation. Unfortunately because there's
nothing in the AST that represents **nothing**, anything we replace that
unused String operation with in the AST will be compiled into something
- even if just the literal atom `nil`. That would probably be better
than unused String operations since those would just be noops in the
runtime, but they would be potentially confusing in the code.

If we want to actually do this there's probably a _lot_ more that would
need to be done for this check, but what we have offers a glimpse into
how this kind of check could be autocorrected as a proof of concept.