Any authenticated encryption mode will do this (at least assuming that the wrong key is independent of the correct one).
Specifically, authenticated encryption guarantees that an attacker who does not know the key will not be able to generate a forged message that would be accepted by the decryptor with a non-negligible probability.
If an attacker would be able to encrypt a message with one key, and have it be accepted as valid when decrypted by another (unrelated) key, then this property would obviously be violated. In particular, an attacker would be able to forge messages simply by picking a random key and using it to encrypt something.
Of course, if such a forged message created by encrypting with a different key was accepted, it would typically decrypt into random garbage. But the definition of unforgeability doesn't care about that; it just says that forged messages should not be accepted at all.*
Note that this argument does have a minor loophole: it only applies if the two keys are chosen independently, leaving open the possibility that a message encrypted with one key might be accepted and decrypted by another related key obtained by making some small change to the original key. Typically, definitions of authenticated encryption don't consider such related-key attacks, and indeed some authenticated encryption schemes do allow them. As fgrieu's answer shows, this includes AES-GCM, at least if the attacker has sufficient control over the original message.
Ps. Even with AES-GCM or other authenticated encryption schemes, it can still sometimes be useful to include an explicit "key check value" of some kind alongside the message. This applies particularly when the message is potentially very long (since GCM, like most AE schemes, needs to process the entire message to determine whether it's valid or not) and when the key is supplied manually by the user (e.g. in a key file or derived from a password entered by the user).
One simple way to create such a key check token for an authentic encryption scheme is to encrypt a zero-length message using the key. If the resulting ciphertext decrypts successfully, the key is almost surely correct. (Of course, an attacker might be able to replace the key check token with a different one, but that counts as malicious tampering that will be detected by the authentication on the actual message.)
*) As a minor exception, some weaker definitions of authenticated encryption may permit the attacker to modify a valid message and have it still be accepted, if the modification doesn't actually change the plaintext the message decrypts to. But most definitions forbid even that.