Major-mode fundctions call `kill-all-local-variables' at start, so these need
to be made buffer-local *after* setting the major-mode to
undo-tree-visualizer-mode, not before. We now set them buffer-local in
undo-tree-visualizer-mode, which seems the appropriate place.

(Thanks to Martin Joerg for flagging this.)

Works around Emacs bug #27779: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27779

New save format serialises the undo-tree, instead of directly writing out the
Elisp object. This avoids triggering a stack overflow in the Emacs Lisp reader
when loading large undo-tree history files, due to the Elisp reader not coping
with deeply nested Elisp objects.

Previous fix didn't copy current node correctly.

Fixes broken undo-tree history saving in recent Emacsen that implement native
defstruct types.

(Better solution would be to implement bespoke undo-tree copier, rather than
relying on copy-tree.)

By default, these are larger than Emacs default values, to avoid history being
discarded as aggressively by Emacs.

- Add undo-tree-canary to buffer-undo-list after loading history, otherwise
  loaded history immediately gets discarded if any new edits are made before
  using undo-tree.

- Recreate undo-tree object pool after loading (discarded when saving).

- Don't auto-save undo history for buffers not associated with any file.

Repeatedly try to copy buffer-undo-list until we succeed without GC occurring,
in an attempt to avoid truncating undo history if some buffer-undo-list cdr is
temporarily null whilst copying due to GC.

Now undo-list-transfer-to-tree first garbage-collects to try to avoid GC of
buffer-undo-list during processing, then deep-copies buffer-undo-list and
operates on the copy to minimise window for GC races.

Not clear if GC races can cause undo history corruption, but mitigating the
chances seems worth a shot.

Simplify undo-list-pop-changeset.

Should be cleared by killing the visualizer, but it writes unreadable data to
file if something goes wrong and for some reason it isn't. So clearing
unconditionally makes things marginally more robust (at the risk of masking
bugs).