improve type traits support

- close #2306

```C++
struct C {
    template<typename T, std::enable_if_t< std::is_integral_t<T>, int> = 0 >
    C( T num ) {}

    template<typename T, std::enable_if_t< std::is_integral_v<T>, int> = 0 >
    int foo( T num ) {}
};

template< typename T, std::enable_if_t< std::is_integral_v<T>, int> >
A operator+( T num ) {}

template< typename T, std::enable_if_t< std::is_integral_v<T>, int> = 0>
A operator+( T num ) {}
```

Author: guwirth

cxx-squid/src/main/java/org/sonar/cxx/parser/CxxGrammarImpl.java

@@ -2182,13 +2182,9 @@ private static void templates(LexerfulGrammarBuilder b) {
         b.sequence( // C++ (PEG: different order) todo one up
           typeConstraint,
           b.firstOf(
-            b.sequence(
-              b.optional(IDENTIFIER), "=",
-              b.firstOf(
-                typeId, // C++
-                initializerClause // syntax sugar to handle type traits providing type name (e.g. std::enable_if_t<>=0)
-              )
-            ),
+            b.sequence(b.optional(IDENTIFIER), "=", typeId), // C++
+            // syntax sugar to handle type traits providing type name (e.g. std::enable_if_t<>=0, std::enable_if_t<>*=nullptr)
+            b.sequence(b.optional("*"), "=", LITERAL),
             b.sequence(b.optional("..."), b.optional(IDENTIFIER)) // C++ (PEG: different order)
           )
         )
@@ -2198,7 +2194,7 @@ private static void templates(LexerfulGrammarBuilder b) {
     b.rule(typeTraits).is( // syntax sugar to handle type traits ...::type  (not part of C++ grammar)
       b.zeroOrMore(b.sequence(IDENTIFIER, "::")),
       simpleTemplateId, "::", "type", b.optional("*"),
-      b.optional("=", initializerClause)
+      b.optional("=", LITERAL)
     );
 
     b.rule(typeParameterKey).is(

cxx-squid/src/test/resources/parser/own/C++14/type-traits-helper.cc

@@ -5,3 +5,25 @@ template <typename T, typename std::enable_if  <std::is_base_of<BaseT, T>::value
 template <typename T, typename std::enable_if  <std::is_base_of<BaseT, T>::value, int>::type>      class B {};
 template <typename T,          std::enable_if_t<std::is_base_of<BaseT, T>::value, int>        = 0> class C {};
 template <typename T,          std::enable_if_t<std::is_base_of<BaseT, T>::value, int>>            class D {};
+
+
+template <typename Collection, std::enable_if_t<std::is_convertible_v<Collection, interface_type>>* = nullptr> class E {};
+template <typename Collection, std::enable_if<std::is_convertible_v<Collection, interface_type>>::type* = nullptr> class F {};
+template <class T, typename std::enable_if  <!std::is_trivially_destructible<T>{} && (std::is_class<T>{} || std::is_union<T>{}), bool>::type = true> class G {};
+template <class T,          std::enable_if_t<!std::is_trivially_destructible<T>{} && (std::is_class<T>{} || std::is_union<T>{}), bool>       = true> class H {};
+
+
+struct I {
+    template<typename T, std::enable_if_t< std::is_integral_t<T>, int> = 0 >
+    I( T num ) {}
+
+    template<typename T, std::enable_if_t< std::is_integral_v<T>, int> = 0 >
+    int foo( T num ) {}
+};
+
+
+template< typename T, std::enable_if_t< std::is_integral_v<T>, int> >
+A operator+( T num ) {}
+
+template< typename T, std::enable_if_t< std::is_integral_v<T>, int> = 0>
+A operator+( T num ) {}