Optimization of initialization of OCCT RTTI

Since about version 6.5.0, OCCT RTTI system initializes all type descriptors defined in a library by the time of loading that library, via use of global variables. This is done in order to prevent possible data races if type descriptors are initialized upon first use (defined as static variables in corresponding getter function) in multithreaded applications.

In OCCT 7 (see #0024947) this feature is also implicitly used to optimize implementation of Standard_Type class: it stores pointers to strings defining its name (user and system) without copying it. This works only if each type descriptor is removed (when last library using it is unloaded) while these pointers are still valid (i.e. they are not part of another library that might have been unloaded previously). Initialization of all descriptors upon library loading is a means to ensure that.

C++11 adds a requirement that static variables should be protected against concurrent initialization (see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm), this would make global variables for types not necessary. Unfortunately, this C++11 feature is not supported by Visual Studio until version 15 (GCC supports it since 4.3).

On the other side, even if not guaranteed by compiler, current implementation of OCCT RTTI should make initialization of type objects as static variables reasonably safe, even in case of concurrency. The point is that types are created in single function (Standard_Type::Register()) which is protected by
mutex. Hence, in the the worst case of concurrency static variable (handle to the type) will be initialized twice, by the same pointer. This will lead to twice incrementing reference counter, and leak of the type descriptor when library is unloaded. This should not be harmful (apart of minor memory leak).

Thus it is proposed to eliminate global type variables (Standard_Type::myInstance). The instance of Standard_Type should keep names of the type as string objects (not as pointers to string literals, as now -- these can be already unloaded by the time of destruction of the type descriptor).

That change should reduce time of loading OCCT libraries, and memory consumption (see timings attached to #0024947).