Why do we need to compute message digest of a message first while signing it? Why is it more efficient to compute a message digest (message &amp; signature) rather than sign the message directly?
One of the main reasons for hashing is that hashing destroys any algebraic structure that is hidden in the signatures. If you don't hash, then in most signature schemes the messages will satisfy some algebraic relation. A typical example is that

$$Sign(m_1m_2)=P(Sign(m_1),Sign(m_2))$$

meaning that the signature of a product/concatenation/whatever of two messages is a polynomial in the signatures of the individual messages. For RSA, we would have $P(x,y)=xy$. These dependencies can be more complicated and as long as they are efficiently computable, we have problems. What a hash function does, informally speaking, is that in terms of bit strings, $H(m_1),H(m_2)$ and $H(m_1m_2)$ become totally unrelated, therefore it removes any sort of efficiently computable dependency of $H(m_1m_2)$ on $H(m_1)$ and $H(m_2)$.

The point of removing these dependencies is that it prevents us from using previously seen message/signature pairs for forging signatures on new messages. This is what breaks EUF-CMA security. Therefore, hashing is not just an issue of efficiency, but also one of security.

Another issue is of course that the message to be signed needs to be of the proper form before a signature is issued. Since a signature scheme typically operates on elements in some group $G$, there needs to be a function that takes a message $M\in\mathcal{M}$ from the message space and maps it to a group element. Therefore, we need some function $H:\mathcal{M}\to G$ that allows us to transfer messages to a format that we can sign. For RSA we need to take an arbitrary bitstring and then turn it into an integer modulo $N$. The kind of a function that does this in a way you want is precisely a cryptographic hash function.

There is actually a theoretical issue here as well. It's very very hard to build a EUF-CMA secure signature scheme without relying on a hash function (meaning not proving security in the Random Oracle Model). There are some quite efficient structure-preserving signature schemes that are EUF-CMA secure and don't use a hash function, but they rely on the generic group model. To my knowledge, no practical construction is known to date, which only depends on a standard assumption.