First of all, let us look at what AAD is; it is a string that must be presented both at encryption and decryption; if the decryptor presents the wrong string, the decryption fails.
Why is this useful? Because AAD can be understood as "encryption context". We typically use the same keys to encrypt several messages. What AAD prevents is the attacker taking one of the valid ciphertexts, and replacing another of the ciphertexts (encrypted with the same key) with it; if the decryptor uses different AADs for the two separate contexts, then the decryption will fail (and the attack is thwarted; if the attacker just wanted the decryption to fail, he could just replace the ciphertext with random gibberish).
An alternative approach would be to just use a separate key each time; that'd work, however AAD generally solves the problem with less complexity.
So, to answer your question:
What is an example problem/scenario that AEAD solves?
You asked for one; I'll give you two:
Consider TLS, where individual records are encrypted with the same key. TLS uses an AAD that includes the record sequence number (which increments with each record); this prevents an attacker from replaying a previously sent record.
Consider database encryption, where we are encrypted individual fields within a database, for example, a database that gives the employee names [1] (unencrypted) and the salary (encrypted). If the attacker could (say) take Alice's salary, and write that into Bob's row, well, that'd be bad. By using the employee name as the AAD, the attacker can't do that undetected.
How does AEAD solve this problem? (not the algorithm details but higher level big picture)
What GCM does is stir in the AAD into the tag; if the AAD isn't correct, the tag would not verify (and you're supposed to reject the decryption in that case).
If AEAD is not used what are attackers able to do?
Replace one ciphertext with another
As a developer should I always use AEAD for everything?
Well, if you're using the same key for multiple purposes, you probably should use a distinct AAD for each encryption. On the other hand, if you're using the key to encrypt only one message (e.g. as the symmetric portion within IES), there is no need
Is AEAD only required for block ciphers but not required for stream ciphers? Is AEAD required when using a public key crypto such as RSA?
Generally, the replay problem needs to be addressed, however stream ciphers and public key methods generally use different approaches.
With stream ciphers, we often generate a single long string, and use distinct portions to encrypt individual messages - this prevents replay attacks. Other times (when we need to be able to decrypt messages out of order), we include a nonce as an input to the stream cipher, and have a higher level protocol ensure that a nonce is not reused.
With public key encryption, it's generally handled at a higher level, possibly with a nonce...
[1]: A real database will be more likely to have some sequence number rather than the name; I'll ignore that for this example.
