For me, it's strong enough and very versatile. It's stronger than what you effectively get in, say, Smalltalk. (Which, technically is strongly typed, having only 1 type of Object.) Having Interfaces explicitly documented in 1 place, but usable through duck typing is genius language design, in my view.
“Strong” and “Weak” don't mean anything in discussions of typing without a reference-point.
(0) Statically typed [e.g., Java] vs. not statically typed [e.g., Python].
(1) Dynamically typed [e.g., Java] vs. not dynamically typed [e.g., Haskell]. Yes, Java is both statically and dynamically typed.
(2) Safe for arbitrary resources [e.g., Rust] vs. only memory-safe [e.g., Python] vs. totally unsafe [e.g., Objective-C].
(3) Typeful [e.g., Haskell] vs. not typeful [e.g., Objective-C].
(4) Global [e.g., Standard ML] vs. local [e.g., Scala] vs. no type inference at all [e.g., Java].
(5) Reflective [e.g., Common Lisp] vs. not reflective [e.g. Rust].
(6) Fixed [e.g., Standard ML] vs. extensible on top of a fixed core [e.g., C++] vs. extensible and modifiable [e.g., Common Lisp].
With respect to Haskell and dynamic typing, I am curious whether you had considered Typeable and Data.Dynamic in your analysis (and, in general, your thoughts on how they relate to the distinction being made).
GHC-specific implementation detail.
> the trust that bad instances are never created
The only way I can trust it is if the compiler enforces it, at which point it isn't “just a library feature”.