Add SpaceBeforeScript linter

Add linter that checks for a space following the '-' or '=' symbols.

An unexpected complication arises when dealing with tags with inline
scripts that span multiple lines via a trailing comma or explicit
multiline vertical bars. In this case, we need to extract the text from
all lines and compare it against the parsed inline text (which is
stripped of leading/trailing whitespace so we can't check it easily) in
order to find out if a separating space exists.

The specs should describe these cases adequately.

In anticipation of many specs of this nature, add a shared example
context which normalizes any `haml` variable defined via `let` so that
the specs can be significantly DRYed up.
Extract HamlVisitor from Linter class

In preparation for adding support for extracting Ruby code from a HAML
file, we're going to want to reuse the Visitor functionality provided by
the `Linter` class.

Extract this functionality into a `HamlVisitor` module which can be
included by any class that wants to be able to visit a HAML parse tree.

As a bonus, this also makes the visitor code easier to test, so add
tests for the new `HamlVisitor` class. In the process of doing this, the
`normalize_haml` spec helper was extracted, which is used to remove
excess indentation from a HAML heredoc for convenience in writing tests.
Add ScriptExtractor visitor

Add a visitor implementation which can extract Ruby code from a HAML
parse tree, storing both the extracted source code and a mapping of the
source code lines to the lines in the original HAML file.

This source code will be passed to a Ruby linter, which can then be used
to find lints in the original HAML via the source map.
Add Ruby script linter

Add a linter that extracts code from a HAML document using the
`ScriptExtractor` and runs it against `rubocop`, a well-developed Ruby
linter.

This provides really powerful linting for `haml-lint` right out of the
box, as most of the common lints (e.g. variable assigned but not used,
single instead of double quotes, etc.) are handled by Rubocop.

The only trick is converting the lint lines reported by Rubocop back to
the lines of the original HAML document. This is achieved by using the
source map of the `ScriptExtractor`, as it keeps track of which lines of
the original HAML document the extracted code came from.

This currently uses some crude regex checks to ignore some unhelpful
lints. This will at some point be replaced by directly integrating with
Rubocop rather than using the CLI.
Run Rubocop directly instead of via CLI

A problem with shelling out to call `rubocop` via CLI is that we have to
pay the startup penalty for both the `haml-lint` Ruby process as well as
`rubocop`'s Ruby process. Furthermore, if we're linting a large number
of HAML files we pay the cost of starting up the `rubocop` process for
each file, which results in linting being very slow.

A solution is to invoke the Rubocop engine directly so we can reuse it
across multiple files. This also ends up simplifying the lint detection
code as we can simply take a Rubocop `Offence` and transform it into a
`Lint` without needing to do any string parsing. It also makes it easier
for us to define which `Cop`s should be ignored as we can reference them
by name rather than inferring them by matching against a regex.