How can I make my stack monad faster?
This code is simply incorrect. It is even not a stack (because it lacks
pop operation and it is impossible to implement it in a type-safe way).
Here is an example:

runStack $ do
  newStackRef (5:: Int)
  newStackRef False
  newStackRef 'x'


according to the definition of the newStackRef it just pokes Storable
representation of the value into the memory block and advances the pointer.
Any information about the type of that value is lost.

To pop a value from such a stack you need to specify correct type and
compiler (or RTS) is not able to warn you if the type is not correct.

To the monad part of the question. From the instance Monad
definition it is easy to see that it almost the same as the State monad (here is how it defined in 
Control.Monad.State.Trans.State.Lazy)

instance (Monad m) =&gt; Monad (StateT s m) where
    return a = state $ \s -&gt; (a, s)
    m &gt;&gt;= k  = StateT $ \s -&gt; do
        ~(a, s') &lt;- runStateT m s
        runStateT (k a) s'


The only difference is that it operates on top of IO an has fixed type of state. So it is actually StateT (Ptr ()) IO.

It is even not clear what it is for a stack to be an instance of Monad.
E.g. list monad allows nondeterministic computations (in prolog-like
style), Maybe monad allows computations that fail.

To enable computation to access and operate stack it is easier to use existing State monad with some stack implementation as a state. I see no reason to implement your own Stack monad.