`isTerminatingType` returns True for abstract classes, resulting in speculative evaluation of bottom
If a class is abstract isTerminatingType currently returns True, and we will speculate types that are terminating.
But if we are inside a module loop, we might see that the type is "abstract" and then speculate on it, even though later when compiling the non-boot file we will see it is a unary class with a single user provided method that can be bottom.
This means that we can try to speculatively evaluate a value
that can be bottom.
We can fix this by adding `&& not (isAbstractTyCon tc)` to `isTerminatingType`
```hs
{-# LANGUAGE KindSignatures #-}
module Callee where -- Callee.hs-boot
import Data.Kind (Type)
class UC (a :: Type)
```
```hs
{-# LANGUAGE GADTs, ScopedTypeVariables #-}
module Mid where
import {-# SOURCE #-} Callee
class UC a => MC a where mcm :: a -> Int
data Dict c where Dict :: c => Dict c
{-# NOINLINE keep #-}
keep :: [Dict c] -> Int
keep xs = length xs + 41
{-# NOINLINE f #-}
f :: forall a. MC a => a -> Int
f _ = keep [Dict :: Dict (UC a)] -- never forces the UC dictionary
```
```hs
module Callee where -- Callee.hs
import Mid
class UC a where ucm :: a -> a -- really unary
instance UC Int where ucm = undefined
instance MC Int where mcm _ = 7
```
```hs
module Main where
import Mid
import Callee ()
main = print (f (1 :: Int))
```
```bash
$ ghc --make -O Main.hs && ./Main
Main: Prelude.undefined
undefined, called at Callee.hs:11:9 in main:Callee
```
issue