fix -Wno_behaviours doc error in dialyzer man page

The description of the -Wno_behaviours in the dialyzer man page incorrectly
includes a "***" footnote marker, indicating that it's an option that turns
on a warning rather than turning it off. Since the option actually turns
off a warning, remove the marker. This fix makes the documentation match
that obtained from dialyzer --help.
ssh: Fix dialyzer type specs and documentation

Similar to d9ebfb8. The wrong specs were leading to dialyzer warnings
like this in our application since R16B03:

The pattern 'ok' can never match the type {'error',_}.
The pattern {'error', {'already_started', 'ssh'}} can never match the type 'ok'.
The pattern {'error', _} can never match the type {'open_error',_,string(),string()}.
v3_core: Annotate list comprehensions to help out dialyzer
Fix +Mea config
Handle map fields in their own function in erl_eval

Map fields (K := V, K => V) are not expressions and shouldn't be clauses of
erl_eval:expr/5.
Support maps in erl_prettypr
observer: Fix crash when clicking on pid inside a html-term
observer: Fix binary links

Heap binaries crashed, rework it and add links always.
So the user can the binary in hex or whatever view he wants
stdlib: Add tests for Maps in erl_prettypr
observer: Fix observer crash when closing crashdumpviewer

Do not saw the branch you are sitting on...
Spawn cdv so that cdv get its own wx environment.
Fix expansion of records in maps

Records were not properly expanded in keys in patterns and in arguments in
map updates.
dialyzer: Silence useless warnings about list comprehensions

Dialyzer will warn if the value of list comprehension is
ignored by putting it in a sequence like this:

  [SomeSideEffect(E) || E <- Es],
  ok

To avoid a warning, you'll have to write:

  _ = [SomeSideEffect(E) || E <- Es],
  ok

Most of the time, this warning is merely annoying because it does
not point out any real errors.

Kostis Sagonas suggested that by suppressing the warning for
list comprehension that return a list of a simple type (e.g. ['ok']),
there would be no warning for code such as:

  [io:format("~p\n", [E]) || E <- Es],
  ok

but there would be still be a warning for:

  [file:close(Fd) || Fd <- Fds],
  ok

because an error condition is ignored.
observer: catch progressbar errors

If cdv window is closed when progressbar was still running error
reports came to error logger (i.e. mostly test problem on slow machines)
Run sys_core_fold twice if any inliner is used
Fix alternative registry type annotations in supervisor

The type annotations for alternative registries using
the {via,Module,Name} syntax was not given for
sup_name() and sup_ref() in the supervisor module.
The type annotation was inconsistent with the
documentation and causes Dialyzer to complain about
valid supervisor:start_link and supervisor:start_child
calls.
Optimise case arguments in sys_core_fold

If the argument of a case expression is a let, a seq or a case with two clauses
where the second one is a failing clause; it can be moved outside the case and
further optimisations can be performed.

module 'foo' ['t'/4]
  attributes []
't'/4 =
  fun (_cor14,Sub0,_cor15,_cor16) ->
    let Ssa = call 'erlang':'get' ('foo') in
      case let Ssa = {'ssa',_cor14,Sub0,_cor15,_cor16} in
           let _rec11 = call 'erlang':'+' (_cor14, 1) in
           let _cor4 = call 'erlang':'setelement' (2, Ssa, _rec11) in
             {{'tmp',_cor14},_cor4} of
        {NewReg,Foo} when 'true' ->
          {NewReg,Foo,Ssa}
        _cor20 when 'true' ->
          primop 'match_failure' ({'case_clause',_cor20})
      end
end

  ==>

module 'foo' ['t'/4]
  attributes []
't'/4 =
  fun (_cor14,Sub0,_cor15,_cor16) ->
    let Ssa = call 'erlang':'get' ('foo') in
    let _fol0 = {'ssa',_cor14,Sub0,_cor15,_cor16} in
    let _rec11 = call 'erlang':'+' (_cor14, 1) in
    let _cor4 = call 'erlang':'setelement' (2, _fol0, _rec11) in
    let NewReg = {'tmp',_cor14} in
      {NewReg,_cor4,Ssa}
end
sys_core_fold: Remove a redundant word in a comment
Teach sys_core_fold:eval_case/2 to cope with handwritten Core Erlang

Starting in e12b7d5331c58b41db06cadfa4af75b78b62a2b1,
sys_core_fold:eval_case/2 will crash on handwritten but legal
Core Erlang programs such as:

   case let <Var> = Arg in {'x',Var} of
      {x,X} -> X
   end

The problem is that the only clause *is* guaranteed to match, but
cerl_clauses:match_list/2 does not understand that; all it can say is
that the clause *may* match. In those circumstances, we will need to
keep the case.

Also make sure that we keep the case if the guard is something else
than 'true'. That is not strictly necessary, because in a legal Core
Erlang program the guard in the last clause in a case must always
evaluate to 'true', so removing the guard test would still leave the
program correct. Keeping the guard, however, will make it somewhat
easier to debug an incorrect Core Erlang program. (The unsafe_case
test case has guard test in the only clause in a case, so we don't
need to write a new test case to test that.)

Reported-by: Anthony Ramine
Allow persistent option on set_env/4 and unset_env/3

An environment key set with the persistent option will not
be overridden by the ones configured in the application resource
file on load. This means persistent values will stick after the
application is loaded and also on application reload.
cover: Support running cover on itself

We want to see at least some coverage of cover itself.