Added Semiring and Rng to spire.algebra hierarchy.

This commit further subdivides Ring functionality. At this point, we
have the following:

  Semiring: (+) (*) with distributivity
  Rig: Semiring with 0 and 1
  Rng: Semiring with 0 and additive inverse (-)
  Ring: Semiring with 0, 1, and (-)

Another way of putting this is:

  Semiring: additive semigroup + multiplicative semigroup
  Rig: additive monoid + multiplicative monoid
  Rng: additive abelian group + multiplicative semigroup
  Ring: additive abelian group + multiplicative monoid

There are currently no types requiring Rng or Semiring in Spire.
However, it would be difficult for users to add these type classes
later (due to ambiguity) so we are adding them anyway.

Finally, the commit attempts to add more detailed descriptions of the
type classes to the README.
improve README formatting
fix embarassing gaffe
Fix more documentation blunders.

Thanks to @ijuma, @jedws, and @tixxit for their vigilance.
Get examples compiling again.
First pass at a KleeneAlgebra example.

The example is taken from: http://r6.ca/blog/20110808T035622Z.html

The code can currently compute transitive closure using an intance of
KleeneAlgebra[Graph]. About 1/3 of the example has been translated to Scala.
Some things to think about:

1. It would be really nice to have a Bounded[A] type class like Haskell.
2. We should probably implement Semiring and Rig for Boolean.
3. Consider better ways to encode square matrix dimension in types.
add Boolean to Rig
get regex and shortest-path examples working
Specialize Semigroup, Monoid and (Ab)Group.
Add some initial Scala Map algebras.

This also adds some benchmarks to make sure our impl of the map
operators is no worse than Algebirds.
RingAlgebra is actually a Rng now.
Add type class instances for Map[K, V].

Adds type class instances for Map. This treats map like a sparse
product, so we can go all the way up to InnerProductSpace.
Add some monoid instances.
Add more collection monoids.
Add monoid for arrays.
Add "vector space" instances for collections.

This adds instances for various seq-like collections that are Modules,
VectorSpaces, and InnerProductSpaces. This let's us use + to do "vector"
addition, dot product, etc.
Add vector space instances for Arrays.

Adds Module, VectorSpace, and InnerProductSpace for Arrays.
Get shortest-path examples working.

This example needs a lot of clean up. Using an almost purely type class
approach is causing me to hit some annoying scoping/organization
issues. I'm really tempted to just define everything in a single object
and use local scope to solve all the issues.

I'm using Scala's Stream to get the equivalent of Haskell's lazy lists.
There could potentially be memoization concerns, but for now I don't
have a better idea (other than implementing a custom stream/list).
Generalize collection instances.

This generalizes the collection instances to work for any collection
type that looks like `CC[A]` and has a `CanBuildFrom[CC[A], A, CC[A]]`.
Move SeqLike instances out to separate file.

I like having everything all in one place, especially since all the
different instances inherit from the more general ones.