short-paths: fix the printing of type manifests

The heuristic for printing types in presence of the short-paths flag works more
or less as follows (at least I think so, if I am mistaken please tell me!):
- fold the environment to construct a table mapping a type to its aliases (i.e.
  the key is the name of the first occurences of the type and the value a list
  of all its aliases, including the keys).
- when printing get the list of aliases and select the "best" (i.e. shortest)
  one which will be printed.

So when we want to print you get ~ that :

    match find_aliases table ty with
    | [] -> print ty
    | x :: xs ->
      let best =
        fold (fun acc elt -> if length acc >= length elt then elt else acc) x xs
      in
      print best

Which is fine considering the aim of the flag.
But now consider this:

    type a
    type t = a

Here our table will contain only { a => [ t ; a ] } (plus some other stuff from
the stdlib, but that's irrellevant).

Now, when we want to print the type t to the user, we usually print it along
with its "manifest" (i.e. "a").
But the thing is, when printing "a" we look in the table, get our list of
aliases and try to find the "best" alias. The candidate which will be picked
here is "t".
So we end up printing : "type t = t"

That problem is avoid by the official compiler/toplevel because it simply
doesn't print type manifests when the -short-paths flag is set.

Nevertheless we would like to keep printing manifests to users (because it does
contain valuable information), so that patch introduce a little hack: we
deactivate the "short-paths" heuristic when printing manifests.

---
N.B. the example given here looks childish, but the same behavior can be
observed with

  module MySuperLongModuleName = struct type a end
  open MySuperLongModuleName
  type t = a

Which is probably common (take a look at the coq source tree).