Restructuring the code to match Ruby standards.

The changes to `lib/` were
[explained\npreviously](https://github.com/tnordloh/RomanNumerals/commit/cffb6ecda9a322ceec717e4deb07d2720c63d0a5#commitcomment-7596237).

I remove what I assume was an unneeded data file and moved the remaining
one to the standard Ruby location of `data/`.

Finally, I added a simple `test` executable that runs through all
numbers in the data file.  Having a command I can repeatedly run to
check correctness makes me feel a lot safer to try a bunch of changes.
Turning on [free debugging](http://devblog.avdi.org/2011/06/23/how-ruby-helps-you-fix-your-broken-code/).
Removing shebang from library file.  Such files aren't meant to be
executed.

I also separated methods with whitespace.  This is a standard Ruby style
and I feel it makes it easier for me to understand the code in the
chunks you broke it into without feeling overwhelmed.
This is me deciding what is the public interface of this object and what
is not.  You may have intended for more of these methods to be used from
the outside, but I stuck with only what is used in `bin/`.

This step was important for my thought process.  I now know what I am
trying to preserve with my changes and what is fair game to drastically
change or remove (anything below `private`).
Making constants (the concept) into constants (Ruby syntax).
Simplifying an algorithm so I can remove some code.

I'm sure the regex is the scary bit here, but let me try to mount a
defense.  First, this is about the dumbest regex you can imagine.
Here's what the code actually produces:

```ruby
ROMAN_CHUNK_REGEX = /(?:IV|CM|CD|IX|XC|XL|L|X|C|V|D|I|M)/
```

I probably should have just hardcoded it and saved readers a heart
attack.  I decided it would be nice to build it from the `Hash` though,
avoiding duplication.  That's the reason I added so many lines of code.
The trickiest bit is where I sort the chunks so two character chunks
will be tried before one character bits.

Finally, in defense of the switch to regex in general I would say that
it's a perfect fit for this problem.  A regex is a specialized tool for
dividing up some characters by meaning.  That's **exactly** what we are
trying to do here.  It's the right tool for this job.

I feel like the fact that it allowed me to turn three methods into one
defends that somewhat.  And it will do more in a second…
Just inlining two methods here.  This temporarily makes things worse,
but I now have all to roman numeral conversion bits in one method.  This
will be handy for the next step…

I did stop converting with `to_i` here.  This means the method now
requires an `Integer`, but I feel like that's a valid expectation in
this case.
Moving this to a class method.  It's really an alternate constructor,
another way to create roman numerals.
It's not useful to have methods I expect to get a number from, like
`to_arabic()`, return `false`.  If I try to do math on that, I'll just
get an error.  Instead, these methods can raise errors directly.

This required me to rework how `convert()` works internally.  It needs
more changes, but we'll circle back to it in a bit.
This is the change I've been fighting for.  Objects are state, plus the
methods that operate on that state.  This code used objects, but not
state, so it was really just a collection of functions.  This commit
turns `RomanNumeral` into a thing and, to me, it makes the whole
structure of the code start to make sense.
My last commit broke `convert()`.  I'm now taking steps to fix it.  The
first step of that is to promote a method it needs to the public
interface.  This is needed because `convert()` is about to move outside
the object scope.  It no longer makes sense there.  This will ensure
that it can still access what it needs after that move.
The movement discussed in the last commit, plus needed fixes.
Moving to more standard Ruby names for these concepts.
Removing a layer of indirection.

If `Enumerator` seems like black magic here, I could have also just
renamed `roman_each()` to `each()` and added `include Enumerable`.  That
would do the same thing.
A fancier use of `inject()`.
The promised second simplification using the added regex.
Minor simplifications.