refactor(longobject): tighten _PyCompactLong_AddWide helpers; keep JIT-free

- Remove the dead `_BINARY_OP_ADD_INT` micro-op (no longer referenced by the macro); remove its abstract op from optimizer_bytecodes.c.
- Annotate `_GUARD_TOS_INT_WIDE`, `_GUARD_NOS_INT_WIDE`, and `_BINARY_OP_ADD_INT_WIDE` as `tier1`-only so the JIT executor and optimizer generator skip them entirely. The JIT defers to tier 1 for any `BINARY_OP_ADD_INT` trace; no new JIT code paths are introduced.
- Add a compact fast-path to `_PyCompactLong_AddWide` so compact-only int addition retains its original `medium_value` cost and avoids the int64-extraction overhead.
- Use `__builtin_add_overflow` in `_Py_i64_add_overflow` on GCC/Clang (single instruction on x86-64 / ARM64).
- Peel the last loop iteration in `_PyLong_TryAsInt64Exact` to hoist the max-digit overflow-guard out of the inner loop body.

Author: KRRT7

Include/internal/pycore_long.h

@@ -422,16 +422,16 @@ _PyLong_TryAsInt64Exact(PyLongObject *v, int64_t *out)
     }
 #endif
     unsigned int shift = 0;
-    for (Py_ssize_t i = 0; i < ndigits; i++) {
-        uint64_t d = (uint64_t)v->long_value.ob_digit[i];
-        if (ndigits == _PY_LONG_MAX_DIGITS_FOR_INT64 && i == ndigits - 1 &&
-            shift != 0 && (d >> (64 - shift)) != 0)
-        {
-            return false;
-        }
-        abs_val |= d << shift;
+    for (Py_ssize_t i = 0; i < ndigits - 1; i++) {
+        abs_val |= (uint64_t)v->long_value.ob_digit[i] << shift;
         shift += PyLong_SHIFT;
     }
+    uint64_t top = (uint64_t)v->long_value.ob_digit[ndigits - 1];
+    /* Prevent UB from an oversized shift when at the maximum digit count. */
+    if (ndigits == _PY_LONG_MAX_DIGITS_FOR_INT64 && (top >> (64 - shift)) != 0) {
+        return false;
+    }
+    abs_val |= top << shift;
     if (abs_val <= (uint64_t)INT64_MAX) {
         *out = sign < 0 ? -(int64_t)abs_val : (int64_t)abs_val;
         return true;