Tests for Vim2 ex command parsers

These tests check two things:

 1. The parser successfully parses the commands it is expected to.
 2. For each sample string, the expected `ExCommand` is selected from the
    `defExCommandParsers`.

They don't check that any `ExCommand` has the affect that it should. Some of
the tests in `TestVim.getTestGroup` do that.

Generating the sample strings for each ex command parser is currently a manual
exercise. Which is why there are currently tests for only a few commands. It
should be possible to generate the command strings using SmallCheck or
QuickCheck.
QuickCheck generates the command strings to parse

Instead of manually generating a hopefully exhaustive set of command strings
to test, use QuickCheck to generate them.

Each ex command parser to test is now contained in a `CommandParser` record.
Along with the parser, the record contains all of the synonyms for the
command, whether the command accepts a `!`, and a `Gen`erator or command line
arguments it is expected to parse.

A number of combinators have been written to ease the generation of arguments.

Currently, only three parsers are tested. However, it should be simple to add
new ones.
Switch form TestFramework to Tasty

In his branch on changing `Rope` to use `Text` instead of `ByteString`,
ethercrow has switched from TestFramework to Tasty. I shall follow his lead
and adjust these too.

I've also reverted `getTestGroup` back to `getTests`.
Tests for pure-editor-manipulating Vim2 actions

The TestVim module provides a nice mechanism for writing tests which are 1)
pure and 2) affect only a single buffer. It doesn't provide a mechanism for
tests which affect more than a single buffer.

Pure manipulations of the editor refers to such things as changing layout,
navigating buffers, creating or deleting buffers, creating or deleting tabs.
In short, anything which 1) doesn't perform IO and 2) interacts with something
other than a single buffer.

This module provides the start of a basis for writing such tests.
Refactor of Vim2 keymap tests

 - A `Vim2` module houses all of the Vim2 keymap specific tests.

 - Split what was `TestVim2PureEditorManipulations` into a number of modules.
   `Vim2.TestUtils` contains utility functions for testing the Vim2 keymaps.
   `Vim2.EditorManipulations.BufferExCommand` contains tests of the `:buffer`
   ex command under the Vim2 keymap. `Vim2.TestPureEditorManipulations` pulls
   the `Vim2.EditorManipulations.BufferExCommand` tests into a test group.

 - Renamed `TestVim` to `Vim2.TestPureBufferManipulations` to reflect that 1)
   it tests the Vim2 keymaps (not the Vim keymaps); 2) it isn't the only set
   of tests for the Vim2 keymaps; and 3) what it tests are pure manipulations
   of a single buffer.
Refactor mkTestCase to use runTest

Refactor `mkTestCase` in `TestPureBufferManipulations` to use `runTest` and
functions from `Vim2.TestUtils`.
Fix parser tests

Include `%` and `#` in the buffer identifier generator, and fix the `:buffer`
command parser to parse them. Specify the correct arguments which `:bdelete`
should parse.
Add and correct module documentation
Remove accidentally committed file
Remove commented out code
Fix hlink warnings in Vim2 test directory
Merge pull request #498 from benarmston/improve-vim2-keymap-tests

Improve vim2 keymap tests