feat(kernel/inductive): track when K-like reduction can be used
feat(kernel/inductive): K-like reduction in the kernel

Given (H_1 : a = a), we have that
      eq.rec H_2 H_1
reduces to H_2

This is not exclusive to equality.
It applies to any inductive datatype in Prop, containing only one
constructor with zero "arguments" (we say they are nullary).

BTW, the restriction to only one constructor is not needed, but it is
does not buy much to support multiple nullary constructors since Prop is
proof irrelevant.
refactor(library/logic): use new K-like reduction to simplify some proofs
refactor(frontends/lean/util): add auxiliary function
fix(frontends/lean/elaborator): incorrect type information being reports in lean-mode, fixes #241
feat(shell): add options --cpp and --discard
feat(frontends/lean): allow variables anywhere
feat(frontends/lean): namespaces also define scope for variables
refactor(library): remove some unnecessary sections
fix(doc/lean/test_single): "race condition" when running tests in parallel
fix(frontends/lean/elaborator): bug when reporting error position
feat(frontends/lean/parser): reject ambiguous parameter declaration, closes #242
refactor(frontends/lean): rename parser methods is_section* to is_local*
fix(emacs/lean-syntax): glitch on syntax highlight
feat(frontends/lean): add 'universe variable' command

We can declare variables anywhere. So, we must also be able do declare
"universe" variables anywhere. Here is a minimal example that requires
this feature

```
-- We want A and B to be in the same universe
universe variable l
variable A : Type.{l}
variable B : Type.{l}
definition tst := A = B
```

The following doesn't work because A and B are in different universes
```
variable A : Type
variable B : Type
definition tst := A = B
```

The following works, but tst is not universe polymorphic, since l is
one *fixed* global universe
```
universe l
variable A : Type.{l}
variable B : Type.{l}
definition tst := A = B
```
refactor(frontends/lean): adjust function names to reflect how parameters/variables behave
feat(library/algebra/category): use variables instead of parameters
refactor(library/algebra/category): remove unnecessary sections
refactor(frontends/lean): do not expose unnecessary functions
feat(frontends/lean/notation_cmd): remove the cleanup notation hack