syntax: add a custom owned smart pointer in ptr::P.
syntax: ast: replace @T with P<T>.
syntax: fold: use move semantics for efficient folding.
syntax: ast_map: use raw pointers into the AST.
syntax: fix fallout from using ptr::P.
syntax: tests: fix fallout from using ptr::P.
rustc: fix fallout from using ptr::P.
rustdoc: fix fallout from using ptr::P.
fourcc: fix fallout from using ptr::P.
hexfloat: fix fallout from using ptr::P.
regex_macros: fix fallout from using ptr::P.
syntax: implement in-place folding of P<T> and Vec<T>.
auto merge of #13316 : eddyb/rust/ast-ptr, r=cmr

Replaces @T in the AST with a custom owned smart pointer, P<T>. Fixes #7929.

## Benefits
* **Identity** (affinity?): sharing AST nodes is bad for the various analysis passes (e.g. one could bypass borrowck with a shared `ExprAddrOf` node taking a mutable borrow), the only reason we haven't hit any serious issues with it is because of inefficient folding passes which will always deduplicate any such shared nodes. Even if we were to switch to an arena, this would still hold, i.e. we wouldn't just use `&'a T` in the AST, but rather an wrapper (`P<'a, T>`?).

* **Immutability**: `P<T>` disallows mutating its inner `T` (unless that contains an `Unsafe` interior, which won't happen in the AST), unlike `~T`.

* **Efficiency**: folding can reuse allocation space for `P<T>` and `Vec<T>`, the latter even when the input and output types differ (as it would be the case with arenas or an AST with type parameters to toggle macro support). Also, various algorithms have been changed from copying `@T` to using `&T` and iterators.

* **Maintainability**: there is another reason I didn't just replace `@T` with `~T`: `P<T>` provides a fixed interface (`Deref`, `and_then` and `map`) which can remain fully functional even if the implementation changes (using a special thread-local heap, for example). Moreover, switching to, e.g. `P<'a, T>` (for a contextual arena) is easy and mostly automated.

## Issues
* **ast_map**: currently using unsafe pointers, could be changed to borrow into a "stable vector" (an abstraction on top of `Unsafe<Vec<~T>>` with one operation, `push(&'a self, T) -> &'a T`).