Include some information about our two releases.

Provide a convenient way of creating a binary package that can be
uploaded to the GitHub releases page.

Well, after all that error handling I'm going to have to remove error
output. The problem was that this STDERR output interfered with the
output of the email in Mutt. When viewing a message, the screen would
become mangled (for certain messages), and I'd have to refresh (Ctrl-L)
the view.

After initially thinking this was because I was using `println!` instead
of flushing a full buffer to STDOUT, I just now realised that my output
to STDERR could be causing the problem. Sure enough, removing the STDERR
output fixed the issue.

This is certainly not ideal, so in the long term we'll probably want to
add some kind of logging mechanism so that users actually have
visibility into errors. But for now and for my own personal purposes, I
think this works. And at least it gets me around the immediate annoying
screen mangling issue.

To save me some time from having to write commands. Started with a
`reinstall` target to make it easier to put a new build on my PATH.

Then added a `test-all` target so I wouldn't have to use two commands to
run both test suites. Needed to create a `test` task also in order to
run the unit tests before the integration test.

Ensure that we `cargo build` before running integration tests. Otherwise
we might be testing against an old build.

Describe the commands to use to run the test suite.

Now that we've actually created and published the GitHub repo, use the
new name. When I wrote the README I just guessed at a name and obviously
that wasn't final.

Discovered that my Mutt aliases file uses the latin1 character encoding.
That caused a "stream did not contain valid UTF-8" error when trying to
read the file in the `Alias#find_in_file` function.

This error was ostensibly triggered by a `str::from_utf8` call in the
standard library
(https://github.com/rust-lang/rust/blob/2174bd97c1458d89a87eb2b614135d7ad68d6f18/src/libstd/io/mod.rs#L315-L338).

I ended up finding this Stack Overflow answer with an easy solution:
http://stackoverflow.com/questions/28169745/what-are-the-options-to-convert-iso-8859-1-latin-1-to-a-string-utf-8/28175593#28175593

      fn latin1_to_string(s: &[u8]) -> String {
          s.iter().map(|c| c as char).collect()
      }

Since latin1 is a subset of Unicode, we can just read the bytes from the
file and typecast them to Rust chars (which are UTF-8). That gives us
the opportunity to easily get the text into an encoding that we can
actually work with in Rust.

At first I got frustrated because the suggestion didn't compile for me.
It was suggested in January 2015, before Rust 1.0, so perhaps that
factors into the error I was getting. Here it is:

    src/alias.rs:59:41: 59:45 error: mismatched types:
     expected `&[u8]`,
        found `core::result::Result<collections::string::String, std::io::error::Error>`
    (expected &-ptr,
        found enum `core::result::Result`) [E0308]
    src/alias.rs:59             let line = latin1_to_string(line);
                                                            ^~~~
    src/alias.rs:59:41: 59:45 help: run `rustc --explain E0308` to see a detailed explanation
    src/alias.rs:99:22: 99:31 error: only `u8` can be cast as `char`, not `&u8`
    src/alias.rs:99     s.iter().map(|c| c as char).collect()
                                         ^~~~~~~~~
    error: aborting due to 2 previous errors

A recommendation from 'niconii' Mozilla#rust-beginners was to use the
Encoding library in order to do the conversion
(https://github.com/lifthrasiir/rust-encoding). That certainly seems
more robust and would be a good idea to try if this change doesn't work
out in the long term. But the Stack Overflow answer just seemed so short
and sweet that I really didn't like the idea of adding a dependency if I
could get what I wanted with 3 lines of code.

Finally took another look and reworked the suggested code to take a
vector (which is what `BufReader#split` gives us) and clone the u8
characters to clear the compiler error of not being able to cast an &u8.