A test to try to get _something_ to compile. And it does!

Here we try to run a plugin with `runReaderT` and `runBot` to pass
`Options` to the plugin, using the "help" plugin as an example. It feeds
hard-coded `Options` to the plugin and outputs its response to STDOUT.

Also get an implementation of `initializePlugins` working that will
allow us to build a list of plugins with `Options` applied to the
reader.

This commit comments out the whole of IRC.hs in order to get the code to
compile. That file still has a bunch of `Bot` monad-related type errors.

To build the final plugin list, I think what we'll want to do is use
something like `initializePlugins` in Lib to apply all our plugins with
the `Options` and then feed that to `connectIRC`. In order to build the
"help" plugin, the plan is to re-apply the `Options` after `ask`ing for
them inside the `PluginAction` for "help" to all plugins, thus enabling
us to get a plugin list with the applied reader for proper localisation
of the help output.

The plugin list's type has changed from `[Plugin]` to `[Bot Plugin]`. In
order for our code here to work, we need to unwrap the `Bot` part so we
can get access to the `Plugin` again and do the same work.

Fortunately, using `sequence`, we can turn our `[Bot Plugin]` into a
`Bot [Plugin]`, which is then easily bound with `<-` and passed to our
old code to be handled like before. Yay!

Add our `Bot` monad to the rest of the plugins:

* Factorial
* GitRemoteSetOrigin
* Help

The only problem is with the Help plugin. Still trying to figure out how
to set up my list comprehension so that it works with the `Bot`-wrapped
`Plugin` list.

Oh my goodness, it works!!!!!!! I've been wrestling with this for the
past week and a half, and it finally works!

Here's the compiler error I was getting:

    sorbot/src/Plugin/GitHubCommit.hs:25:12: error:
        • Couldn't match type ‘Control.Monad.Trans.Reader.ReaderT r0 m1’
                         with ‘Bot’
          Expected type: Bot t0
            Actual type: Control.Monad.Trans.Reader.ReaderT r0 m1 t0
        • In a stmt of a 'do' block: cfg <- asks language
          In the expression:
            do { cfg <- asks language;
                 return
                   (defaultPlugin
                      {matchRegex = "^[0-9a-f]{40}$", perform = gitHubCommitAction,
                       command = "<git_sha>",
                       description = translate (lang cfg) GitHubCommitDescription}) }
          In an equation for ‘gitHubCommit’:
              gitHubCommit
                = do { cfg <- asks language;
                       return
                         (defaultPlugin
                            {matchRegex = "^[0-9a-f]{40}$", perform = gitHubCommitAction,
                             command = "<git_sha>",
                             description = translate (lang cfg) GitHubCommitDescription}) }

The problem ended up being that I was using the wrong `ask` & `asks`
functions. After a lot of searching online and reading articles and
things about how to set up `ReaderT` configuration, I finally started
looking at some code, from a "language:Haskell newtype app readert"
search on GitHub. Reading different code bits, I tried to compare with
what I had already, kept reading. Finally I noticed that the imports
were different, and I tried getting `ask` not from the transformer
library, and it worked!! OMG! So glad.

Since we're trying to get the language from an `Options` type in the
reader, we need to use the `language` helper instead of our custom
`lang` (which operates on `IO`).

Tried adding this to replicate some code I had been reading, but
ultimately it didn't really change anything. In the end I don't need
this type, at least not right now, but it was an interesting exercise I
suppose.

Added this for whatever reason trying to get types to line up, but it's
not necessary. In fact, I didn't even really notice it as I was bothered
by another compiler error, but 'monochrom' on Freenode#haskell pointed
it out, thanks.

This is an attempt at wrapping the functions in this plugin with the new
`Bot` monad. It didn't go very well.

These changes are the result of some initial code and then a lot of
fiddling to try to resolve compiler errors, many of which are still
present.

The ultimate goal is to be able to wrap the functions in `Bot` so that
we can use the language configuration option to determine which
translation to use.

Thanks to 'dmwit' on Freenode#haskell for looking at my code and giving
me suggestions for my type errors.

Replace the `IO` return monad with `Bot`. `Bot` wraps the `IO` monad so
it should cover us for that, while additionally providing configuration
to plugin action functions.

There's also some extra cruft here from when I was experimenting. The
commit before this one and the next one or more were all written at once
in a jumbled mess. All the extra code is collateral from that.