move Liskov.isa method to LiskovInstances

for implicit priority. prepare dotty

```
scala> implicitly[scalaz.Liskov[Int, Int]]
1 |implicitly[scalaz.Liskov[Int, Int]]
  |                                   ^
  |According to new implicit resolution rules, this will be ambiguous:
  |both method isa in object Liskov and method refl in object Liskov match type scalaz.Liskov[Int, Int]
val res0: scalaz.Liskov[Int, Int] = scalaz.Liskov$$anon$2@25022628
```

core/src/main/scala/scalaz/Liskov.scala

@@ -30,6 +30,12 @@ sealed abstract class LiskovInstances {
 
     def compose[A, B, C](bc: B <~< C, ab: A <~< B): (A <~< C) = trans(bc, ab)
   }
+
+  /** Lift Scala's subtyping relationship */
+  implicit def isa[A, B >: A]: A <~< B = new (A <~< B) {
+    def substCo[F[+ _]](p: F[A]) = p
+    def substCt[F[- _]](p: F[B]) = p
+  }
 }
 
 object Liskov extends LiskovInstances {
@@ -40,12 +46,6 @@ object Liskov extends LiskovInstances {
   /** A flipped alias, for those used to their arrows running left to right */
   type >~>[+B, -A] = Liskov[A, B]
 
-  /** Lift Scala's subtyping relationship */
-  implicit def isa[A, B >: A]: A <~< B = new (A <~< B) {
-    def substCo[F[+ _]](p: F[A]) = p
-    def substCt[F[- _]](p: F[B]) = p
-  }
-
   /** We can witness equality by using it to convert between types */
   implicit def witness[A, B](lt: A <~< B): A => B = {
     type f[-X] = X => B