Smooth out some kinds with Eq/Order.
version bump to M7 (2.10.0)
Use Context.fresh to give unique term names in cfor macro.

- Some simple unit tests for cfor.
- Note: Context.fresh is deprecated in 2.10.1 for Context.freshName
fix Rational#% bug
cleanup Complex
add fun.max and fun.min
Merge remote-tracking branch 'lossyrob/pullreq/cfor-Context.fresh' into 2.10.0
Package restructure and API updates.

This commit moves methods from the spire.math.fun objedct into the
spire.math package object. Previously package objects were a bit too
broken to use. Here's hoping that they will work out moving forward.

Other small changes include efficiency improvements to SafeLong's
comparison methods, removing some unsavory implicits from UByte-ULong,
and some other improvements.
add bit-shifting to SafeLong
clean up imports
add missing operators to SafeLong
update Rational with changes to SafeLong/spire.math
add bit operations to SafeLong
Add bit operations to Number, with other improvements.

This commit adds some more Number tests, and cleans up the code dealing
with different kinds of Numbers. It also fixes some equality bugs.
Start to rationalize support for Fractional[A].

This commit fixes some ambiguous implicit problems with Fractional[A].
The Integral/Fractional/Numeric type classes haven't seen so much
attention and need a bit more love.

This commit adds support for literal Doubles when working with Fractional
(analogous to the support for literal Int with Rings). Arguably we should
move this to Field instead, but it works for now.

The reason it might make sense to move to Field is that this commit still
doesn't support using literal doubles with Numeric[A].
Clean up the implicit operator situation.

It turns out that having multiple implicit conversions that provide
(different) versions of operators like "-" is dicey at best. This
commit unifies all the overloads for a given operator into a single
implicit, so that it can be applied first and then the correct
overload will be chosen.

This change allows us to support Int/Double literals via spire.algebra
type classes when the relevant conversions are available (Ring for Int
and ConvertableTo for Double).

Closes #46.
Another attempt to improve the plight of spire.math.Number.

This commit adds a ton of type class instances for Number. It also
adds some implicit operators to coerce other types into Numbers
when combined with them. Only time will tell if this is the right
thing to do, but without this working with Number will probably be
really annoying.

All of the following should work:

  import spire.math._
  import spire.implicits._

  Trig[Number].sin(Number(2.3))
  BigDecimal(87) + Number(76)
  SafeLong(123) + Number(19) + 123.123124
  (Number(3) :: Number(1) :: Number(2) :: Nil).qsorted
Fix spire.math.compat implicit precedence.
add modPow to SafeLong
add test for SafeLong