Can polymorphism be simulated by lazy type operators?
It's not entirely clear to me how your idea is supposed to work, but everything you're doing can just simply be done with a bit of more high-powered type theory. That is, if we allow quantification over types then we can talk about polymorphism. Let's go from easy examples to the ones you're talking about.

A function such as
$$f \, x = (x,x)$$
is polymorphic in the type of $x$: if $x$ has type $A$ then $f$ has type $A \to A \times A$. We can express this sort of dependency by intrducing an extra argument so that $f$ has type $\prod_{A : \mathsf{Type}} A \to A \times A$ and is defined by
$$f \, A \, x = (x, x).$$

Your example is like this, except a bit more complicated. To keep examples simple, let me instead used a simplified class (the whole Num is a bit large)

class Cow a where
  one :: a
  plus :: a -&gt; a -&gt; a


and consider a functio dependent on Cow:

plusOne :: Cow a =&gt; a -&gt; a
plusOne x = plus x one


We can express plusOne as before, except that now it takes three extra parameters: a type $A$, an element of $A$, and a function $A \to A \to A$. So its type would be
$$
\prod_{A : \mathsf{Type}} A \to (A \to A \to A) \to A \to A
$$
and it would be defined by
$$\mathtt{plusOne} \; A \; \mathtt{one} \; \mathtt{plus} \; x =
  \mathtt{plus} \; x \; \mathtt{one}.$$
This is a general trick: polymorphism can always be replaced by passing around extra arguments, but the price you pay is that you will have dependent types and there might be many extra arguments.