Because it is problematic. Its a dangerous thing to do. Errors in code that does it can be devilishly hard to track down.
Perhaps an illustration will help.
I once had some code in K&R C that was calling a function with a float as an argument. Simplest thing in the world really. What could go wrong?
The problem was the function wasn't declared before it was called in one program unit (an error on my part). Under the K&R rules this compiler implemented, that meant the compiler assumed it existed as a function returning int, and any parameters sent to it were supposed to be int as well. So the compiler's code it generated to call this routine converted the float parameter to an int before pushing it on the stack.
The code implementing the function off in a different .c file of course knew nothing about this, and when it pulled that parameter off the stack, treated the int as a float.
This was a nightmare to debug, because as far as I knew there were no compilation or link errors, and everything looked coded correctly. The types in the source code matched up. The symptom (my data getting trashed) had no obvious relation to the ultimate coding error. It didn't look like I was doing anything unsafe or dangerous anywhere. Days were wasted.
The moral here (aside from "K&R C sucks"), is that type reinterpretation of bits is a hazardous operation. If the coder does something wrong it can cause really difficult to track down bugs.
Its perhaps worth thinking about this as the dataflow equivalent of a goto statement for control flows. A code maintainer looking at an object and seeing its type will have expectations about how the data contained by that object will be used, how it can be changed, and what its values can be. All of those assumptions are out the window once its type representation has been munged.
This is why modern languages are (usually) designed to make such operations difficult and ugly. Not happening silently, like my K&R compiler/linker was doing. The idea is that the language should both discourage casual use of this feature, and implement it in a way that makes its existence in source code very difficult to miss.
Of course the obvious next question is, why allow it at all? Well, its tough to do a lot of low-level programming without it. For example, the entire concept of a protocol stack relies on every layer of protocol code treating the contents of higher layers as untyped data. Higher layers in fact know some of that data is a specific header structure, and the highest layer most likely wants to transmit some floats.