        Enter extended "WAYBACK MACHINE" mode.

        The global `-w <tgtag>` option must be specified (but as a special
        case for the `shell` command a <tgtag> destination of `:` may be
        used to get a shell with no wayback ref changes).

        The "<tgtag>" value must be the name of a tag created by (or known to)
        "tg tag".  However, it may also have a `:` prefixed to it to
        indicate that it should prune (making it into a "pruning wayback tag").
        Use of a "pruning wayback tag" results in a repository that contains
        exclusively those refs listed in the specified tag.  Otherwise the
        wayback repository will just revert those refs while keeping the others
        untouched (the default behavior).

        The "WAYBACK MACHINE" activates as normal for the specified
        destination but then a new `${SHELL:-/bin/sh}` is spawned in a
        temporary non-bare repository directory that shares all the same
        objects from the repository but has its own copy of the ref namespace
        where the refs specified in the wayback destination have all been
        changed to have their wayback values.

        If any arguments are given a POSIX shell will be spawned instead
        concatenating all the arguments together with a space and passing
        them to it via a `-c` option.  If `-q` (or `--quote`) is given
        then each argument will first be separately "quoted" to protect it from
        the shell allowing something like this:

                tg -w <tgtag> shell -q git for-each-ref --format="%(refname)"

        to work without needing to manually add the extra level of quoting that
        would otherwise be required due to the parentheses.

        Most of the repository configuration will be inherited, but some
        will be overridden for safety and for convenience.  All "gc" activity
        within the wayback repository will be suppressed to avoid accidents
        (i.e. no auto gc will run and "gc" commands will complain and not run).
        
        Override and/or bypass this safety protection at your own peril!
        Especially *do not run* the `git prune` plumbing command in the
        wayback repository!  If you do so (or bypass any of the other safeties)
        be prepared for corruption and loss of data in the repository.
        Just *don't do that* in the first place!

        Using `git wayback-tag` will show the tag used to enter the wayback
        machine.  Using `git wayback-updates` will show ref changes that have
        occurred since the wayback tag was created (it will not show refs that
        have since been created unless a pruning wayback tag was used).
        Finally, `git wayback-repository` will show the home repository but
        so will `git remote -v` in the output displayed for the `wayback`
        remote.

        The special `wayback` remote refers to the original repository and
        can be used to push ref changes back to it.  Note, however, that all
        default push refspecs are disabled for safety and an explicit refspec
        will need to be used to do so.

        Unlike the normal "WAYBACK MACHINE" mode, `HEAD` will be detached
        to a new commit with an empty tree that contains the message and author
        from the wayback tag used.  This prevents ugly status displays while
        avoiding the need to checkout any files into the temporary working
        tree.  The parent of this commit will, however, be set to the wayback
        tag's commit making it easy to access if desired.

        Also unlike the normal "WAYBACK MACHINE" mode, there are no
        limitations on what can be done in the temporary repository.
        And since it will be non-bare and writable, commands that may not have
        been allowed in the original repository will work too.

        When the shell spawned by this command exits, the temporary wayback
        repository and all newly created objects and ref changes made in it, if
        any, *will be lost*.  If work has been done in it that needs to be
        saved, it must be pushed somewhere (even if only back to the original
        repository using the special `wayback` remote).

        Lastly there's the `--directory` option.  If the `--directory`
        option is used the temporary "wayback repository" will be created at
        the specified location (which must either not exist or must be an empty
        directory -- no force option available this time as too many things
        could easily go wrong in that case).  If the `--directory` option is
        used then the "wayback repository" *will persist* after `tg shell`
        completes allowing it to continue to be used!  Be warned though, all
        the same warnings that apply to `git clone --shared` apply to such
        a repository.  If it's created using a `tgstash` tag those warnings
        are especially salient.  Use a single argument of either `:` (to
        just create with no output) or `pwd` (to show the full absolute path
        to the new "wayback repository") when using the `--directory` option
        if the sole purpose is just to create the wayback repository for use.
        Note that the `--directory` option *must* be listed as the first
        option after the `shell` command name if used.

