Arrows are strong profunctors

This changes Arrows from extending Profunctor to extending a new
type-class called `Strong` which extracts out the `first` and `second`
methods.

A dual `Costrong` type-class is included which has `cofirst` and
`cosecond`.

Instances are provided for Kleisli and Cokeisli.
Rename Costrong to ProChoice

The original name was take from Choice's Haskell doc, which says:

> The generalization of DownStar of a "costrong" Functor

But it seems that is wrong:

> <edwardk> puffnfresh: my notion of costrength refined after i wrote that

Easy fix:

> <edwardk> ProfunctorChoice or ProChoice is fine

The syntax names have also changed, since they're not dual functions -
they just operate on coproducts rather than products. The new names are:

* `proleft`
* `proright`
Correct implementation of Heaviside step function; see http://en.wikipedia.org/wiki/Heaviside_step_function
fix two typos
meant to use typesafe equals
add FunctorUsage
add BifunctorUsage
Merge pull request #801 from stew/add-TagUsage

Add tag usage
Merge pull request #800 from NickPollard/topic/heaviside

Correct implementation of Heaviside step function
Merge pull request #798 from puffnfresh/feature/strong-costrong

Arrows are strong profunctors
pick some of cody's nits :wq
OCD: Obsessive CeeDubs: fixed more speling and stuffs :wq
Fix EitherT MonadListen/Tell breakage
Merge pull request #802 from stew/add-AddFuntorUsage

Add FunctorUsage / BifunctorUsage
EphemeralStream.iterate doesn't include the start value

Before:
scala> scalaz.EphemeralStream.iterate(0)(_ + 1).take(5).to[Vector]
res6: Vector[Int] = Vector(1, 2, 3, 4, 5)
scala> Stream.iterate(0)(_ + 1).take(5).to[Vector]
res7: Vector[Int] = Vector(0, 1, 2, 3, 4)

After:
scala> scalaz.EphemeralStream.iterate(0)(_ + 1).take(5).to[Vector]
res0: Vector[Int] = Vector(0, 1, 2, 3, 4)

Thanks goes to @betehess for discovering the bug.
Add Functor.widen

I have implemented this via `map` and `Liskov.apply`. In many cases,
we could probably cheat by using `Liskov.subst` along with a variance
hack (such as in `IList.widen`) or `asInstanceOf`, which may be more
performant than using `map`. However, this would be a dirty hack, and
usually those are accompanied with bugs.

Can anyone recommend a safe yet more performant way to write this
generally? If not, we probably will want to consider overriding the
implementation for more instances for the sake of performance. At this
point I have only overridden the implementation for `IList`.
fix failing test cases (thanks @ceedubs)
Merge pull request #810 from stew/fix-ephemeral-stream-iterate

EphemeralStream.iterate doesn't include the start value
Fix typo in readme
Merge pull request #813 from MrAIring/series/7.2.x

Fix typo in readme