First passing code for complement.

There is duplication here, both of behavior and of knowledge.

Duplication of behavior is code approaches that look the same, like the
case statements in the `find_dna` and `find_rna` methods. Those look the
same, so extraction seems beneficial. But of the 4 case options, only 2
are shared between the methods. So extraction might make things more
difficult.

Duplication of knowledge is in the two public API methods. They both
expect a string and then they are going to return its complements. They
both know how clients are going to use this code. That duplicated
knowledge seems like a good thing to dry up
Extract duplicated knowledge

The duplicated knowledge of how clients will use the system has been put
into just one method that both public-facing methods now use.
Extract 'type' variable use out to classes

Using 'type' as the parameter in `build_complement_for` is a flag that
we need classes here, so this commit creates RNA and DNA classes.
Shouldn't strands build their own complement

Previous commit had RNA and DNA as a single nucleotide, but that left
them unable to deal with strands, this Complement had to handle strands.
That felt odd. So now we have RNA and DNA as something with strands and
that can break down strands into nucleotides. Complement just serves as
a thin wrapper around these classes
In which I show off my poor knowledge of biology

What we're trying to capture here is what DNA turns into when it becomes
RNA, and vice versa, right? I'm a little vague on the biology,
admittedly. This whole 'complement' thing seems like a different way of
saying Ruby's `to_` idiom. So, while keeping the current Complement API,
I'm going to rewrite the underling code to use `to_dna` and `to_rna`

Along with this, I'm reversing the responsibility for knowing
complements. Previously, RNA would check itself for a complement to one
of its own nucleotides, but I think the best way to model this is for it
to ask DNA. It's converting `to_dna` so it seems like DNA would know the
right nucleotide matches. But, again, I probably got a C- in High School Biology
Extract shared behavior with inheritance

RNA and DNA are both types of NucleicAcids, so lets reflect that with
inheritance.

Initially I was not in favor of this approach because it meant defining
.to_dna on DNA and .to_rna on RNA. They have to respond to these methods
to satisfy Liskov Substitution.

But then I thought about Ruby supporting methods like "x".to_s and
1.to_int. So having .to_dna on DNA follows in that tradition.
Extract out transcription knowledge

The only variable here was what it was transcribing to, otherwise the
behavior was exactly the same.