Enhance ability to link with C++

This is a work in progress and is _NOT_ ready to be merged.  I've opened this at Walter's request.
Windows only.

@braddr: I'm not sure how to go about adding test cases for this.  Any suggestions?

Currently, the following are supported in dmd:

- c++ 'class' virtual functions

- c++ free functions

- c++ global variables

This patch adds/changes following:

- extern(C++) classes are un-disabled

- Correct mangling for static and non-virtual member functions for classes, structs and interfaces

- Correct mangling for static and non-static member variables of structs and classes

- Constructors and destructors of c++ classes and interfaces are mangled correctly

- final can be used on c++ member functions to force non-virtual

- c++ dtors are not automatically non-virtual (and are no longer disabled)

- Template structs and classes are mangled correctly when used as a return type, a parameter type, or parent of a function/variable

- C++ mangled names are not compressed (this was causing what looked like corruption, I have no idea why) or hashed


Basically, things link now.  And when I say link, I mean LINK.  Not much beyond that has been tested yet.


```D
extern(C++)
struct Struct
{
  int member;
  static extern int staticmember;
  void memberfunc();
  static void staticfun();

  this();
  ~this();
}

extern(C++)
class Class
{
  int member;
  static extern int staticmember;
  void virtualfun();
  final void memberfunc();
  static void staticfun();

  this();
  ~this(); // virtual dtor, use final to force non-virtual
}

extern(C++)
interface I
{
  static extern int staticmember;
  void virtualfun();
  static void staticfun();
}

extern(C++)
class CT(T)
{
  int member;
  static extern int staticmember;
  void virtualfun();
  final void memberfunc();
  static void staticfun();
}

alias CT!int TT;

extern(C++)
extern int global;

extern(C++)
void globalfun();

extern(C++)
TT templatefun(TT, TT);
```

```C++
struct Struct
{
  int member;
  static int staticmember;
  void memberfunc() {}
  static void staticfun() {}

  Struct() {}
  ~Struct() {}
};

class Class
{
  int member;
  static int staticmember;
  virtual void virtualfun() {}
  void memberfunc() {}
  static void staticfun() {}

  Class();
  virtual ~Class();
};

class I
{
  static int staticmember;
  virtual void virtualfun() {}
  static void staticfun() {}
};

template<typename T>
class CT
{
  int member;
  static int staticmember;
  virtual void virtualfun() {}
  void memberfunc() {}
  static void staticfun() {}
};

typedef CT<int> TT;

int global;

void globalfun() {}

TT templatefun(TT, TT) {}
```

Things missing:
- variables in template struct/classes
- variables that are template struct/classes
- template non-type parameters
- mangling of special functions other than ctor and dtor
- mangling global special functions
- a way to support c++ value type classes embedded in other classes / as globals
- mangling of struct vs class and int vs long and d keywords
- debug information - dmd just crashes at the moment
- non-windows support - I don't have a linux box set up to test on at the moment

Test cases, patches and advice welcome (_especially_ advice on the backend and mangling voodoo)

Edit: variables inside templates are now supported