Dependent type synonym in recursive type family causes GHC to panic

Background

I had written the following code in Haskell (GHC):

{-# LANGUAGE 
  NoImplicitPrelude,
  TypeInType, PolyKinds, DataKinds,
  ScopedTypeVariables,
  TypeFamilies,
  UndecidableInstances
#-}

import Data.Kind(Type)

data PolyType k (t :: k)

type Wrap (t :: k) = PolyType k t
type Unwrap pt = (GetType pt :: GetKind pt)

type family GetKind (pt :: Type) :: Type where
  GetKind (PolyType k t) = k

type family GetType (pt :: Type) :: k where
  GetType (PolyType k t) = t

The intention of this code is to allow me to wrap a type of an arbitrary kind into a type (namely PolyType) of a single kind (namely Type) and then reverse the process (i.e. unwrap it) later.

Problem

I wanted to define a function that would recursively operate on a composite type like so:

data Composite :: a -> b -> Type

type family RecursiveWrap expr where
  RecursiveWrap (Composite a b) = 
    Wrap (Composite (Unwrap (RecursiveWrap a)) (Unwrap (RecursiveWrap b)))
  RecursiveWrap x = Wrap x

However, the above definition causes GHC to panic:

ghc.exe: panic! (the 'impossible' happened)
  (GHC version 8.4.3 for x86_64-unknown-mingw32):
        cyclic evaluation in fixIO  

Ideas

If we inline the the Unwrap synoynm into the defintion of the type family above like so:

type family RecursiveWrap expr where
  RecursiveWrap (Composite a b) = 
    Wrap (Composite 
      (GetType (RecursiveWrap a) :: GetKind (RecursiveWrap a)) 
      (GetType (RecursiveWrap a) :: GetKind (RecursiveWrap a))
    )
  RecursiveWrap x = Wrap x

GHC instead simply produces an error:

* Type constructor `RecursiveWrap' cannot be used here
  (it is defined and used in the same recursive group)
* In the first argument of `GetKind', namely `(RecursiveWrap a)'
  In the kind `GetKind (RecursiveWrap a)'
  In the first argument of `Composite', namely
    `(GetType (RecursiveWrap a) :: GetKind (RecursiveWrap a))'

As such, I suspect this has to do with the recursive type family appearing in the kind signature when the Unwrap type synonym is expanded.

However, it strikes me as odd that even the above code errors. Since with the UndecidableInstances extension turned on, I think that I should be able to write recursive type families like the above. Especially given that the above family would not loop indefinitely and thus be reducible.