[Graphics Tools][Analytics]Introduce analytics for Lifetime and usage.

Introducing two analytics for our Graphics tools: https://jira.unity3d.com/browse/GFXFOUND-452

```   
// schema = com.unity3d.data.schemas.editor.analytics.uGraphicsToolLifetimeAnalytic_v2
// taxonomy = editor.analytics.uGraphicsToolLifetimeAnalytic.v2
```
and

```  
// schema = com.unity3d.data.schemas.editor.analytics.uGraphicsToolUsageAnalytic_v1
// taxonomy = editor.analytics.uGraphicsToolUsageAnalytic.v1
```

#### Frame Debugger
- Lifetime
- Enable/Disabled actions

#### Rendering Debugger
- Lifetime
- Widget value changed

#### Render Graph Viewer
- Lifetime

#### URP Converter
- Lifetime
- Convert action

#### HDRP Wizard
- Lifetime
- Fix/Fix all actions
- Convert actions

Author: alex-vazquez-unity3d

Packages/com.unity.render-pipelines.core/Editor/Analytics/AnalyticsUtils.cs

@@ -156,53 +156,93 @@ static Dictionary<string, string> GetDiffAsDictionary(Type type, object current,
 
             foreach (var field in type.GetSerializableFields())
             {
-                var t = field.FieldType;
-                try
-                {
-                    if (t.GetCustomAttribute<ObsoleteAttribute>() != null || typeof(ScriptableObject).IsAssignableFrom(t))
-                        continue;
+                var fieldType = field.FieldType;
+                if (!IsFieldIgnored(fieldType))
+                    AddDiff(current, defaults, field, fieldType, diff);
+            }
 
-                    var valueCurrent = current != null ? field.GetValue(current) : null;
-                    var valueDefault = defaults != null ? field.GetValue(defaults) : null;
+            return diff;
+        }
 
-                    if (t == typeof(string))
-                    {
-                        var stringCurrent = (string)valueCurrent;
-                        var stringDefault = (string)valueDefault;
-                        if (stringCurrent != stringDefault)
-                        {
-                            diff[field.Name] = stringCurrent;
-                        }
-                    }
-                    else if (t.IsPrimitive || t.IsEnum)
-                    {
-                        if (!valueCurrent.Equals(valueDefault))
-                            diff[field.Name] = ConvertPrimitiveWithInvariants(valueCurrent);
-                    }
-                    else if (t.IsArray && valueCurrent is IList valueCurrentList)
-                    {
-                        if (AreArraysDifferent(valueCurrentList, valueDefault as IList))
-                            diff[field.Name] = valueCurrentList.DumpValues();
-                    }
-                    else if (t.IsClass || t.IsValueType)
-                    {
-                        if (valueCurrent is IEnumerable ea)
-                            continue; // List<T> not supported
+        private static void AddDiff(object current, object defaults, FieldInfo field, Type fieldType, Dictionary<string, string> diff)
+        {
+            try
+            {
+                var valueCurrent = current != null ? field.GetValue(current) : null;
+                var valueDefault = defaults != null ? field.GetValue(defaults) : null;
+                AddIfDifferent(field, fieldType, diff, valueCurrent, valueDefault);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"Exception found while parsing {field}, {ex}");
+            }
+        }
 
-                        var subDiff = GetDiffAsDictionary(t, valueCurrent, valueDefault);
-                        foreach (var d in subDiff)
-                        {
-                            diff[field.Name + "." + d.Key] = d.Value;
-                        }
+        private static void AddIfDifferent(FieldInfo field, Type fieldType, Dictionary<string, string> diff, object valueCurrent, object valueDefault)
+        {
+            if (!AreValuesEqual(fieldType, valueCurrent, valueDefault))
+            {
+                if (IsComplexType(fieldType))
+                {
+                    var subDiff = GetDiffAsDictionary(fieldType, valueCurrent, valueDefault);
+                    foreach (var d in subDiff)
+                    {
+                        diff[$"{field.Name}.{d.Key}"] = d.Value;
                     }
                 }
-                catch (Exception ex)
+                else
                 {
-                    Debug.LogError($"Exception found while parsing {field}, {ex}");
+                    diff[field.Name] = ConvertValueToString(valueCurrent);
                 }
             }
+        }
 
-            return diff;
+        static bool IsFieldIgnored(Type fieldType)
+        {
+            return fieldType.GetCustomAttribute<ObsoleteAttribute>() != null || typeof(ScriptableObject).IsAssignableFrom(fieldType);
+        }
+
+        internal static bool AreValuesEqual(Type fieldType, object valueCurrent, object valueDefault)
+        {
+            if (fieldType == typeof(string))
+                return (string)valueCurrent == (string)valueDefault;
+
+            if (fieldType.IsPrimitive || fieldType.IsEnum)
+                return valueCurrent.Equals(valueDefault);
+
+            if (fieldType.IsArray && valueCurrent is IList currentList)
+                return !AreArraysDifferent(currentList, valueDefault as IList);
+
+            if (valueCurrent == null && valueDefault == null)
+                return true;
+
+            return valueDefault?.Equals(valueCurrent) ?? valueCurrent?.Equals(null) ?? false;
+        }
+
+        internal static bool IsComplexType(Type fieldType)
+        {
+            // Primitive types and enums are not considered complex
+            if (fieldType.IsPrimitive || fieldType.IsEnum)
+                return false;
+
+            // String is considered a primitive type for our purposes
+            if (fieldType == typeof(string))
+                return false;
+
+            // Arrays can be converted to string easy without sub-elements
+            if (fieldType.IsArray)
+                return false;
+
+            // Value types (structs) that are not primitive are considered complex
+            // Classes are considered complex types
+            return fieldType.IsValueType || fieldType.IsClass;
+        }
+
+        static string ConvertValueToString(object value)
+        {
+            if (value == null) return null;
+            if (value is IList list) return list.DumpValues();
+            return ConvertPrimitiveWithInvariants(value);
         }
 
         static string ConvertPrimitiveWithInvariants(object obj)
@@ -212,17 +252,49 @@ static string ConvertPrimitiveWithInvariants(object obj)
             return obj.ToString();
         }
 
-        static string[] ToStringArray(Dictionary<string, string> diff)
+        static string[] ToStringArray(Dictionary<string, string> diff, string format = null)
         {
             var changedSettings = new string[diff.Count];
 
+            if (string.IsNullOrEmpty(format))
+                format = @"{{""{0}"":""{1}""}}";
+
             int i = 0;
             foreach (var d in diff)
-                changedSettings[i++] = $@"{{""{d.Key}"":""{d.Value}""}}";
+                changedSettings[i++] = string.Format(format, d.Key, d.Value);
 
             return changedSettings;
         }
 
+        private static string[] EnumerableToNestedColumn<T>([DisallowNull] this IEnumerable collection)
+        {
+            using (ListPool<string>.Get(out var tmp))
+            {
+                foreach (var element in collection)
+                {
+                    string[] elementColumns = ToStringArray(DumpValues(element.GetType(), element), @"""{0}"":""{1}""");
+                    tmp.Add("{" + string.Join(", ", elementColumns) + "}");
+                }
+
+                return tmp.ToArray();
+            }
+        }
+
+        private static string[] ToNestedColumnSimplify<T>([DisallowNull] this T current)
+            where T : new()
+        {
+            var type = current.GetType();
+
+            if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(T)))
+            {
+                var instance = ScriptableObject.CreateInstance(type);
+                ToStringArray(GetDiffAsDictionary(type, current, instance));
+                ScriptableObject.DestroyImmediate(instance);
+            }
+
+            return ToStringArray(GetDiffAsDictionary(type, current, new T()));
+        }
+
         /// <summary>
         /// Obtains the Serialized fields and values in form of nested columns for BigQuery
         /// https://cloud.google.com/bigquery/docs/nested-repeated
@@ -238,28 +310,13 @@ public static string[] ToNestedColumn<T>([DisallowNull] this T current, bool com
             if (current == null)
                 throw new ArgumentNullException(nameof(current));
 
-            var type = current.GetType();
+            if (current is IEnumerable currentAsEnumerable)
+                return EnumerableToNestedColumn<T>(currentAsEnumerable);
 
-            Dictionary<string, string> diff;
             if (compareAndSimplifyWithDefault)
-            {
-                if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(T)))
-                {
-                    var instance = ScriptableObject.CreateInstance(type);
-                    diff = GetDiffAsDictionary(type, current, instance);
-                    ScriptableObject.DestroyImmediate(instance);
-                }
-                else
-                {
-                    diff = GetDiffAsDictionary(type, current, new T());
-                }
-            }
-            else
-            {
-                diff = DumpValues(type, current);
-            }
+                return ToNestedColumnSimplify(current);
 
-            return ToStringArray(diff);
+            return ToStringArray(DumpValues(current.GetType(), current));
         }
 
         /// <summary>