Simplify validation check to single-level if statement

Changed the NotSupportedException validation logic from nested if statements
to a single-level if with a compound condition using logical operators.

This addresses PR review feedback to:
- Remove unnecessary nesting
- Fix indentation issues
- Make the logic more readable and maintainable

The condition now checks all invalid type scenarios in one expression:
- Non-primitive and non-enum types
- float and double primitives
- Enums backed by float or double

All 705 tests pass successfully.

Co-authored-by: EgorBo <523221+EgorBo@users.noreply.github.com>

Author: Copilot

src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs

@@ -652,13 +652,12 @@ public static unsafe T And<T>(ref T location1, T value) where T : struct
         {
             // Only integer primitive types and enum types backed by integer types are supported.
             // Floating-point types and floating-point backed enums are not supported.
-        if (!typeof(T).IsPrimitive || typeof(T) == typeof(float) || typeof(T) == typeof(double))
-        {
-            if (!typeof(T).IsEnum || typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))
+            if ((!typeof(T).IsPrimitive && !typeof(T).IsEnum) ||
+                typeof(T) == typeof(float) || typeof(T) == typeof(double) ||
+                (typeof(T).IsEnum && (typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))))
             {
                 throw new NotSupportedException(SR.NotSupported_IntegerEnumOrPrimitiveTypeRequired);
             }
-        }
 
             // For 1-byte and 2-byte types, we need to use CompareExchange-based implementations
             // because there are no direct atomic And operations for these sizes.
@@ -796,13 +795,12 @@ public static unsafe T Or<T>(ref T location1, T value) where T : struct
         {
             // Only integer primitive types and enum types backed by integer types are supported.
             // Floating-point types and floating-point backed enums are not supported.
-        if (!typeof(T).IsPrimitive || typeof(T) == typeof(float) || typeof(T) == typeof(double))
-        {
-            if (!typeof(T).IsEnum || typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))
+            if ((!typeof(T).IsPrimitive && !typeof(T).IsEnum) ||
+                typeof(T) == typeof(float) || typeof(T) == typeof(double) ||
+                (typeof(T).IsEnum && (typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))))
             {
                 throw new NotSupportedException(SR.NotSupported_IntegerEnumOrPrimitiveTypeRequired);
             }
-        }
 
             // For 1-byte and 2-byte types, we need to use CompareExchange-based implementations
             // because there are no direct atomic Or operations for these sizes.