        Show overview of all TopGit-tracked topic branches and their
        up-to-date status.  With a branch name limit output to that branch.
        Using `--deps-only` or `--rdeps` changes the default from all
        branches to just the current `HEAD` branch but using `--all` as
        the branch name will show results for all branches instead of `HEAD`.

                `>`
                        marks the current topic branch

                `0`
                        indicates that it introduces no changes of its own

                `l`/`r`
                        indicates respectively whether it is local-only
                        or has a remote mate

                `L`/`R`
                        indicates respectively if it is ahead or out-of-date
                        with respect to its remote mate

                `D`
                        indicates that it is out-of-date with respect to its
                        dependencies

                `!`
                        indicates that it has missing dependencies [even if
                        they are recursive ones]

                `B`
                        indicates that it is out-of-date with respect to
                        its base

                `*`
                        indicates it is ahead of (and needs to be merged into)
                        at least one of its dependents -- only computed when
                        showing all branches or using the (possibly implied)
                        `--with-deps` option.

        This can take a longish time to accurately determine all the
        relevant information about each branch; you can pass `-t` (or `-l`
        or `--list`) to get just a terse list of topic branch names quickly.
        Also adding `--verbose` (or `-v`) includes the subjects too.
        Adding a second `--verbose` includes annihilated branches as well.

        Passing `--heads` shows independent topic branch names and when
        combined with `--rdeps` behaves as though `--rdeps` were run with
        the output of `--heads`.

        The `--heads-independent` option works just like `--heads` except
        that it computes the heads using `git merge-base --independent`
        rather than examining the TopGit `.topdeps` relationships.  If the
        TopGit branches are all up-to-date (as shown in `tg summary`) then
        both `--heads` and `--heads-independent` should compute the same
        list of heads (unless some overlapping TopGit branches have been
        manually created).  If not all the TopGit branches are up-to-date then
        the `--heads-independent` results may have extra items in it, but
        occasionally that's what's needed; usually it's the wrong answer.
        (Note that `--topgit-heads` is accepted as an alias for `--heads`
        as well.)

        Using `--heads-only` behaves as though the output of `--heads` was
        passed as the list of branches along with `--without-deps`.

        Alternatively, you can pass `--graphviz` to get a dot-suitable output
        for drawing a dependency graph between the topic branches.

        You can also use the `--sort` option to sort the branches using
        a topological sort.  This is especially useful if each
        TopGit-tracked topic branch depends on a single parent branch,
        since it will then print the branches in the dependency order.
        In more complex scenarios, a text graph view would be much more
        useful, but that has not yet been implemented.

        The `--deps` option outputs dependency information between
        branches in a machine-readable format.  Feed this to `tsort` to
        get the output from --sort.

        The `--deps-only` option outputs a sorted list of the unique branch
        names given on the command line plus all of their recursive
        dependencies (subject to `--exclude` of course).  When
        `--deps-only` is given the default is to just display information for
        `HEAD`, but that can be changed by using `--all` as the branch
        name.  Each branch name will appear only once in the output no matter
        how many times it's visited while tracing the dependency graph or how
        many branch names are given on the command line to process.

        The `--rdeps` option outputs dependency information in an indented
        text format that clearly shows all the dependencies and their
        relationships to one another.  When `--rdeps` is given the default is
        to just display information for `HEAD`, but that can be changed by
        using `--all` as the branch name or by adding the `--heads` option.
        Note that `tg summary --rdeps --heads` can be particularly helpful in
        seeing all the TopGit-controlled branches in the repository and their
        relationships to one another.

        Note that `--rdeps` has two flavors.  The first (and default) is
        `--rdeps-once` which only shows the dependencies of a branch when
        it's first visited.  For example, if D depends on several other
        branches perhaps recursively and both branch A and B depend on D, then
        whichever of A or B is shown first will show the entire dependency
        chain for D underneath it and the other one will just show a line for
        D itself with a "^" appended to indicate that the rest of the deps for
        D can be found above.  This can make the output a bit more compact
        without actually losing any information which is why it's the default.
        However, using the `--rdeps-full` variant will repeat the full
        dependency chain every time it's encountered.

        Adding `--with-deps` replaces the given list of branches (which will
        default to `HEAD` if none are given) with the result of running
        `tg summary --deps-only --tgish` on the list of branches.  This can
        be helpful in limiting `tg summary` output to only the list of given
        branches and their dependencies when many TopGit-controlled branches
        are present in the repository.  Use `--without-deps` to switch back
        to the old behavior.

        The `--with-related` option extends (and therefore implies)
        `--with-deps`.  First the list of branches (which will default to
        `HEAD` if none are given) is replaced with the result of running
        `tg summary --heads` (aka `--topgit-heads`) and the result is then
        processed as though it had been specified using `--with-deps`.

        When it would be allowed, `--with-deps` is now the default.  But,
        if in addition, exactly one branch is specified (either explicitly
        or implicitly) and it's spelled *exactly* as `HEAD` or `@` then
        the default `--with-deps` will be promoted to a default
        `--with-related` instead.  Since duplicate branches are removed
        before processing, explicitly listing `@` twice provides an easy way
        to defeat this automatic promotion and ask for `--with-deps` on the
        `HEAD` symbolic ref with minimal typing when `--with-related` isn't
        really wanted and typing the full `--with-deps` option is too hard.

        With `--exclude branch`, branch can be excluded from the output
        meaning it will be skipped and its name will be omitted from any
        dependency output.  The `--exclude` option may be repeated to omit
        more than one branch from the output.  Limiting the output to a single
        branch that has been excluded will result in no output at all.

        The `--tgish-only` option behaves as though any non-TopGit-controlled
        dependencies encountered during processing had been listed after an
        `--exclude` option.

        Note that the branch name can be specified as `HEAD` or `@` as a
        shortcut for the TopGit-controlled branch that `HEAD` is a
        symbolic ref to.  The `tg summary @` and `tg summary @ @` commands
        can be quite useful.

