I can't speak to whether any compilers did this.
I can only examine why they probably didn't.
The simplest reason is performance.
Hashing is CPU intensive. Having to hash every single identifier gets expensive quickly. The value of the extended identifiers is low in contrast to the repeated CPU load and burden this puts on the compiler.
You said "a simple alternative". But it's not simple. CPU cycles were precious back in the day. Very precious. Folks spent inordinate amounts of time to reduce cycle counts, and reduce memory. We had to suffer through more than just short identifiers to get code written back then.
Also, by the time CPUs started to actually speed up to where we could "afford" to do this in terms of CPU budget, we already more of a memory budget to wit it would become unnecessary.
Finally, the actual limitation had minimal impact. Folks wrote very large BASIC programs back when the variables were limited to 2 letters or a letter and a number. 936 identifiers. I recall working with a lady and the warehousing system she had written. She extolled her use of "Z9" as her global error variable. When it came to identifiers, we had enough, we had bigger fish to fry to get projects written.
As with many things back then, it would have been a "nice to have", but we couldn't afford it.
Actually I have thought of an example where hashing was used.
I believe in early versions of Forth, the dictionary used a mechanic where it stored a limited amount of letters of the identifier, but it also stored the length. Other languages, perhaps BASIC, may have done this too.
So, let's say it stored 2 letters (I don't recall the actual value),
THING would, indeed be different even though internally only
T H were stored because the length, 4 and 5 respectively, was also stored. Now,
THING would be identical. But it did allow the identifier space to be expanded somewhat, and this is certainly a form of hashing.
Also, in later Forth implementations (F83 does this), the dictionary was threaded in to 4 different parts in order to speed up lookups. It hashed each identifier to discern which thread it would go on. Mind, this, again, was trivial hashing -- it was just breaking the vocabulary in to 4 different parts. It just took the bottom 2 bits of the first character of the identifier. But, it was hashed, just not directly for the purposes suggested here.