Spurious superclass cycle error with type equalities

Some of us today had an idea how to repair Edward Kmett's regrettably unsound Data.Constraint.Forall module. The method works fine in some cases, but seems to occasionally trigger a spurious superclass cycle error.

In the cases I've seen so far, it seems to happen when a class is defined with a Forall superclass, where that Forall itself has as parameter another class, that itself has a type equality superclass.

Example file (a bit larger than necessary to show how a similar example without a type equality ''doesn't'' give an error):

{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleContexts #-}

import Data.Monoid
import GHC.Exts (Constraint)

type family Skolem (p :: k -> Constraint) :: k
type family SkolemF (p :: k2 -> Constraint) (f :: k1 -> k2) :: k1

-- | A quantified constraint
type Forall (p :: k -> Constraint) = p (Skolem p)
type ForallF (p :: k2 -> Constraint) (f :: k1 -> k2) = p (f (SkolemF p f))

-- These work
class ForallF Monoid t => Monoid1 t
instance ForallF Monoid t => Monoid1 t

class ForallF Monoid1 t => Monoid2 t
instance ForallF Monoid1 t => Monoid2 t

-- Changing f a ~ g a to, (Ord (f a), Ord (g a)), say, removes the error
class (f a ~ g a) => H f g a
instance (f a ~ g a) => H f g a

-- This one gives a superclass cycle error.
class Forall (H f g) => H1 f g
instance Forall (H f g) => H1 f g

And the resulting error:

Test.hs:31:1:
    Cycle in class declaration (via superclasses):
      H1 -> Forall -> H -> H
    In the class declaration for ‘H1’

Test.hs:31:1:
    Cycle in class declaration (via superclasses):
      H1 -> Forall -> H -> H
    In the class declaration for ‘H1’