[RFC] Object creation and destruction concept
I propose this basic concept and want to hear your comments:
* NiGuiObject is the base type for all complex types like Window, Control, Button, etc.
* NiGuiObject types are ref types, that means objects are stored on heap and are not destroyed automatically.
* To create a NiGuiObject, there is a 'new' proc for each type, e.g. 
```nim
proc newButton(): Button =
  result = new Button
  result.Button.init()
  # (In reality it creates a NativeButton, I can explain this somewhere else.)
  [...]
``` 
* The 'new' proc calls the 'init' proc, e.g. 
```nim
proc init(button: Button) =
  button.Control.init() # call 'init' of base type
  # do some initialization:
  button.fText = ""
  [...]
```
* The 'init' proc calls the 'init' proc of it's direct base type.
* To destroy an NiGuiObject and free it's memory, there is the 'dispose' method:
```nim
method dispose(obj: NiGuiObject)
```
* The 'dispose' method should be overridden for sub types.
* There is another 'dispose' proc but with 'var' parameter, which sets the reference to nil after disposal:
```nim
proc dispose(obj: var NiGuiObject) =
  let o = obj
  o.dispose() # force calling the other 'dispose' proc
  obj = nil
```

More thoughts:
* In a typical small GUI application, the programmer does not care about object destruction. GUI objects simply live until the end of the program. In multi window applications it might be useful to dispose a window object when the window gets closed. The window will dispose all it's controls automatically.
* Is it useful to have a 'onDispose' event?
* Is it useful to have a 'disposed' property to forbid usage of a disposed object?

Implementation:
* The described concept is mostly already implemented, except that at the moment there is no common base type of Window and Control. The needed changes will be small.