Have each `write_to_file` test pass in a custom filename to the helper
function. This way each test has its own file to deal with, eliminating
the race condition when running tests in parallel (the default).

If we get an `AliasSearchError::NotFound` error we still want to write
the alias to the file. After all, it's an email we haven't encountered
yet so we should store an alias for it.

If the email exists, we can do what we were doing before and change the
current alias to be unique.

Rename our "append" `write_to_file` test method to be a little more
clear about its purpose.

Create a new `write_to_file` test function that tests the case we're
adding here.

Note that having these two tests together seems to cause a race
condition because they're both using the same temporary test file. If we
run tests with `RUST_TEST_THREADS=1 cargo test` then they pass. Will see
about fixing that next.

We want to be able to write a test that ensures aliases can be written
to the file even if they don't already exist.

To do this, I want to be able to reuse the code in the helper function.
We can't use the code that appends to the file because this is relevant
only to the `alias_write_to_file_must_write_given_alias_to_file` test
(which I just realised should actually be renamed to something more
specific).

In order to run this code without requiring it to be in the helper
function, extract it to a closure that gets passed to the helper.

We need to pass `alias` into the function explicitly in order to use it
otherwise we get an error on an immutable borrow.

Create a new helper function that does the work of
`alias_write_to_file_must_write_given_alias_to_file`. We want to be able
to add another test of the `write_to_file` method that does the same
thing but for non-preexisting aliases. Making a helper method will allow
us to avoid duplicating work.

Take all of our Alias code, functions, errors, etc. and move them into
their own module. This removes some clutter from our `main.rs` file and
makes things better organised. Now all the alias code lives in its own
dedicated place.

Update our test file imports to match this change.

Updates to alias code:

* Reordered imports alphabetically
* Made `Alias` public
* Made `AliasSearchError` public
* Made all methods on `Alias` public

Expand the responsibility of `Alias#write_to_file` so that it performs
what it used to do plus all of what `write_alias` did.

This allows us to consolidate the functionality into a single method,
and move it into the `Alias` implementation.

The change required some modification to our `write_to_file` test:

* Create our test alias as mutable
* Write a new alias to the test file based on our test alias but with a
  different email. This allows the `write_to_file` method to work
  without erroring with an `AliasSearchError::NotFound`.
* Needed to `derive(Clone)` on `Alias` in order to be able to easily
  clone it into the new near-duplicate alias.
* Change our `unwrap()` calls to `expect()` to make it easier to see
  where exactly we panicked. Otherwise I didn't really have any way of
  knowing.
* Add some comments for clarity

Makes more sense for this function to live in a method on `Alias`
because it operates directly on an alias.

Refactor our tests and code to support this new organisation.

The test compiler complained that I should make my constant uppercase.
Do this to eliminate our compiler warnings.

Changed the test to use a file with multiple alias lines for a more
real-world scenario. Achieving this by copying the `testdata/aliases`
file into a new temporary test file instead of creating a new blank
file.

Then needed to change our assertion so that we get the correct line from
the file to compare on. This is always the last line in the file. Note
that `.len() - 2` is used because `.len() - 1` is the final newline.

The test change revealed two errors in my code:

1. I needed to open the file for appending, not just for writing.
2. A newline needs to be appended to the end of the file (otherwise all
   our aliases get written to the same line).

Fix the errors.

Writes the alias to a given file.

Thinking I should modify the test so that we can know it works with
multiple alias lines.