Clean up code in inifile.c
Reference types are non-POD
Merge pull request #3060 from ibuclaw/refpod

Reference types are non-POD
fix Issue 12622 - Purity, @safe not checked for pointers to functions
Merge pull request #3489 from 9rnsr/fix12622

Issue 12622 - Purity, @safe not checked for pointers to functions
fix Issue 12689 - [CTFE] assigning via pointer from 'in' expression doesn't work
Merge pull request #3521 from 9rnsr/fix12689

Issue 12689 - [CTFE] assigning via pointer from 'in' expression doesn't work
Merge pull request #3354 from yebblies/inifile

[cleanup] Untangle the rat's nest in inifile.c
fix Issue 12688 - Strange error if function call is in parentheses

`(s.foo).writeln` is parsed as `DotIdExp(TypeExp('s.foo'), 'writeln')`, but the type `s.foo` should be analyzed as dotvar expression.
fix Issue 12673 - ICE with static assert and __traits(compiles) with non-existent symbol
Merge pull request #3525 from 9rnsr/fix12673

Issue 12673 - ICE with static assert and __traits(compiles) with non-existent symbol
Add license to visitor header
Merge pull request #3523 from ibuclaw/visitorlicense

Add license to visitor header
Merge pull request #3524 from 9rnsr/fix12688

Issue 12688 - Strange error if function call is in parentheses
Fix issue 313 & 314

Points:

1. Most of import declarations will insert their fully qualified names in local symbol table.

Currently, it is stored only in one place - `Module::modules`. After this change, in addition to that,
each `ScopeDsymbol::symtab` will have the "local package tree" which represents the scope local imports.

For example:

```d
class C {
    import core.stdc.stdio;
    import core.stdc.stdlib : malloc;
    import core.stdc.stdlib : free;
    void func() {
        import core.stdc.string;
    }
}
```

`symtab` of class `C` and `C.func` will have following package object trees:

```
// in C
Package('core') <----------+
 + Package('stdc') <-------|--+
    + Import('stdio')      |  |
    + Import('stdlib')     |  |
        names = ["malloc"] |  |
  +---- overnext           |  |
  |                        |  |
  +-> Import('stdlib')     |  |
        names = ["free"]   |  |
                           |  |
// in C.func()             |  |
Package('core') aliassym --+  |
 + Package('stdc') aliassym -+
    + Import('string')
```

In there, `Import` object will be the leaf of the tree.
It's done by `Import::addPackage`.

2. A part of local package tree will be merged into other tree.

This example case of public import should work.

```d
module a;
public import std.stdio;
```
```d
module b;
import a;
import std.algorithm;
std.stdio.writeln();    // point
```

In module b, 'std.stdio' should be visible. To realize it, import declarations will pull
the fully qualified name of public imports in the imported module.
Finally, module b will have the package tree:

```d
Package('std')
 + Package('algorithm')
 + Package('stdio')   <--- Pulled from module a, by `import a;`
```

Same work is necessary on class inheritance. Public/protected imports in base class scope
should be pulled in the derived class scope.
Add test/compilable/testimport1.d
Add test/compilable/testimport2.d
Add test/compilable/testimport3.d
Add test/compilable/testimport4.d
fix Issue 313 - [module] Fully qualified names bypass private imports