The way that this is overcome is that most garbage collectors only permit direct pointers to an object rather than to a particular field inside an object. For example, there's no Java equivalent to this C:

  void a(int *b)
  {
      *b = 5;
  }

  struct c
  {
      int d;
  };

  int main()
  {
      struct c foo;
      a(&foo.d); // no way to do this in Java!
      printf("%lu\n", (unsigned long)foo.d);
  }

As has been pointed out, you can disallow direct pointers into the middle of things and use offsets instead. I'm curious though, because I don't know much about ARM, why function pointers can't be forced into even alignment? If it's 3rd party binary code you might have a problem, but if you control the compilation you can add NOP padding to get whatever alignment you want.

There's nothing that requires any particular alignment on x86/x64 either, but it's standard for most compilers because it makes everything run faster at minimal size cost.

First, pointers are typically unsigned integers. Second, memory addresses are virtual, they don't have to exist physically. That is, you don't have to physically have up through 2 quintillion addressable bytes for a pointer with that value to be valid. This is especially true with Address Space Layout Randomization (ASLR) security techniques employed by operating systems.

tl;dr: all valid pointer values are possible, regardless of how much memory you actually have.

There could be addressable memory with the high bit set, for example ROM space for booting or video memory.

That may be rare nowadays (or is it? I remember reading recently that some 64-bit CPU chose to preferably use a memory range from -2GB to +2GB. AMD64?), but whether there is is outside of the control of most language implementers. They can control their own memory allocator, though, and guarantee that it never stores 64-bit quantities at odd addresses.

The issue is that pointers with the high bit set are commonplace, whereas pointers that are not aligned to the processor's word size are easily avoided (and on some architectures, outright invalid).