That's only somewhat true. You can express arbitrary graphs pretty easily with an arena, which has some similarities to GC in terms of how you use it but flat out isn't garbage collection (unlike reference counting) or unsafe (at least, not after an incoming Rust patch lands). There has also been discussion for some time in the Haskell community around the feasibility of a non-garbage collected implementation of Haskell (the consensus seems to be that it is doable, though perhaps not wholly practical).
More generally, Rust is not the final word in type systems around data structures, and for more complex ones there are more complex type systems.
Owning pointers, regions, arenas, etc, are various ways to take advantage of special cases in the correlation of object lifetimes. But here's no general solution that isn't GC. For example with arenas, you won't be able to reclaim any memory if your memory graph has nodes with uncorrelated lifetimes.
Consider, for example, a double-linked list that grows to a certain size, then every second a random node is deleted and a new one is inserted at the beginning. You can't represent the double-linked list with owning pointers, and while you can represent the list in an arena, you can't reclaim any memory until the whole list is deleted.
There was a reason I included the second paragraph. There are type systems that can handle intrusive data structures. However, they aren't used in any mainstream language (affine types in Rust is already a major achievement).
More generally, Rust is not the final word in type systems around data structures, and for more complex ones there are more complex type systems.