Inconsistent `ApplicativeError` behaviour for `OptionT[F[_], A]` / `EitherT[F[_], A, B]` if `F[_]` also has an `ApplicativeError` instance

For example, if F[_] is Either[Throwable, *], there would exist 2 instances of ApplicativeError for OptionT[Either[Throwable, *], *]:

ApplicativeError[OptionT[Either[Throwable, *], *], Throwable] // higher priority instance derived from `F[_]`
ApplicativeError[OptionT[Either[Throwable, *], *], Unit] // default instance for all `OptionT`

The instance derived from F[_] would be higher in priority and this would result in inconsistency with the default behaviour (when F[_] does not have an ApplicativeError instance), e.g.:

import cats.implicits._
import cats.{Applicative, ApplicativeError, Monoid}
import cats.data.OptionT

def handleErrorWithMonoidEmpty[F[_], A, E: ApplicativeError[F, *]](fa: F[A])(implicit A: Monoid[A]) = fa.handleError(_ => A.empty)

// if `F[_]` is `List`, it handles `None` as error
handleErrorWithMonoidEmpty(OptionT.none[List, Int]) //OptionT(List(Some(0)))

// if `F[_]` is `Either[Throwable, *]`, it handles for `Throwable` instead
handleErrorWithMonoidEmpty(OptionT.none[Either[Throwable, *], Int]) //OptionT(Right(None))
handleErrorWithMonoidEmpty(new Throwable("throw").raiseError[OptionT[Either[Throwable, *], *], Int]) //OptionT(Right(Some(0)))

The same issue exist for EitherT:
The instance priorities are reversed for EitherT:

ApplicativeError[EitherT[Either[Throwable, *], String, *], Throwable]
ApplicativeError[EitherT[Either[Throwable, *], String, *], String] //this would be higher in priority

Start by inspecting the ApplicativeError instances for OptionT and EitherT, using the conflicting type examples in the issue to trace instance priority and behavior. Done means the chosen instances behave consistently whether the underlying F has an ApplicativeError instance or not, including the OptionT and EitherT cases described.