TL;DR: Use a proper key derivation function instead of some homegrown scheme.
the hash can easily be extracted and brute-forced externally.
I think you are very much underestimating the difficulty of a preimage attack on a modern password hash function.
Is it safe? Since I haven't seen this anywhere, I'm not sure if I overlooked something that could make this system vulnerable.
Done right, what you propose might not be actually vulnerable, but it also probably wouldn't buy you much. Done wrong, as discussed in previous answers, it can become horribly insecure.
Basically, when you think of hashing passwords, don't think just a single round of your average cryptographic hash function such as MD5 or SHA512. Instead, your first choice should be to use a properly salted password-based key derivation function. There are many such available, but the more popular choices currently seem to be PBKDF2 and bcrypt, with scrypt growing in popularity.
Unlike plain hash primitives, key derivation functions are specifically designed to be slow as well as try to give an attacker as little advantage as possible, even where the attacker is able to use custom hardware to attack the password entered by the user, even if that password has relatively low entropy.
You can still store something that indicates whether the password is correct. For example, LUKS does this by storing a salted cryptographic hash of the master key; if the passphrase provided by the user doesn't correctly decrypt any of the key slots, then the decryption of the master key data in the key slot will yield an incorrect result, resulting in a different master key hash, which is detected and acted upon as an "incorrect passphrase" result. Notice in this case that the hash of the passphrase itself is not stored. Compare the LUKS on-disk format, figure 1 PHDR layout.