Casting pointers to integers - better pointer data type propagation

In the decompiled code, there are often constructions like this:
Original code:
```c
size_t my_strlen(const char * str) {
const char *s;
for (s = str; *s; ++s);
return(s - str);
}
```
Decompiled code:
```c
int32_t my_strlen(char * str) {
int32_t v1 = (int32_t)str;
int32_t v2 = v1;
while (*(char *)v2 != 0) {
v2++;
}
return v2 - v1;
}
```
It is not ideal, pointers should be propagated better. The current code works only on 32-bit systems - if we want to recompile it (as we do in regression tests), option `-m32` has to be used. Otherwise, we would be casting 64-bit pointers to `int32_t`, which clearly would not work.

We will not be able to solve this 100%, since this is how it works in assembly and our analyses can not be always perfect. But we should try:
- Better type propagation - some of those variables could be pointers.
- Simple patterns identification and optimization - e.g. detect chain `pointer -> integer -> pointer`, and get rid of these casts.
- etc.

The issue does not name implementation files, tests, or an entry point. Start by reproducing the shown pointer-to-integer output and tracing the existing type propagation; done means pointer types are preserved or redundant pointer–integer–pointer casts are removed without breaking regression recompilation on 64-bit systems.

Written by the indexing model from the issue text.