Q:

Do monads not guarantee the applicability of layered/non-layered monadic values to non-layered/non-monadic functions, and is this a good/bad thing? 

I'm just trying to get monads, so bear with me if I ask a bad question, but...
If monads only require:

(a -> M a), where M is the monadic type constructor, and
(M a -> (a -> M b) -> M b), which is the bind operation (which I understand as mapping a monad onto a non-monadic to monadic value function)

...doesn't this mean that:

(M a -> a) and
(M (M a) -> M a) are not implicitly required? 

Won't this usually cause a problem? 

Suppose we have a set of functions, S, which all have the type (x -> y), where x and y are arbitrary types. 
Now, suppose I program using a set of monadic functions M, where their types are x -> M y.

Doesn't this mean that once I turn a type into M y, I can't use any of the (x -> y) functions?  Or, can I assume that I can do (M x -> (x -> y) -> (y -> M y) -> M y)? 
Furthermore, don't we usually want to extract the original type when programming?   When switching between something, like async a -> a or maybe a -> a... Isn't that a common operation?  I can definitely see the case where somebody wants to optimize a monad out if they see it as negligible (e.g. a logging monad). 
Additionally, what about layered monads without flattening?  I understand that lists can be seen as monads where restricting flattening is a clear and logical choice, but what about the hypothetical case of async (async a) monadic values where async has no flatten function?  Does bind only imply one layer of "monadic reduction" where we can often assume that (M a -> (a -> M a) -> M a) can often be seen as (M a -> (M a -> a) -> (a -> M a) -> M a), and (M M a -> (a -> M a) -> M a or M M a) may not work?  Is there a true difference between flattening and non-flattening monads? 

A:

Won't this usually cause a problem? 

You might say that this is "by design".  One of the possible uses is IO; once you have a value tainted with IO, you have to "bubble up"; you can't hide the fact that a function is doing IO under a pure value. 

wouldn't that mean I either have to manually convert each (a -> b) -> (a -> M b) by applying a monadic constructor somewhere? 

This is easier than you think because every Monad is also a Functor and an Applicative Functor:
randomDice :: IO Int
randomDice = randomRIO (1,6)

cheat :: Int -> Int
cheat = (+1)

main = do
    dice <- randomDice
    dice' <- cheat <$> randomDice

Having all of the fmap, <$>, liftA/liftM and pure/return machinery at our disposal, it makes it very simple to easily use pure functions in the monadic contexts. 

(M (M a) -> M a) is not implicitly required

That one is false.  You only need bind to implement it. 
join              :: (Monad m) => m (m a) -> m a
join x            =  x >>= id

