Implement our own small-integer optimization (#7584)

## Summary

This is a follow-up to #7469 that attempts to achieve similar gains, but
without introducing malachite. Instead, this PR removes the `BigInt`
type altogether, instead opting for a simple enum that allows us to
store small integers directly and only allocate for values greater than
`i64`:

```rust
/// A Python integer literal. Represents both small (fits in an `i64`) and large integers.
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct Int(Number);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Number {
    /// A "small" number that can be represented as an `i64`.
    Small(i64),
    /// A "large" number that cannot be represented as an `i64`.
    Big(Box<str>),
}

impl std::fmt::Display for Number {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Number::Small(value) => write!(f, "{value}"),
            Number::Big(value) => write!(f, "{value}"),
        }
    }
}
```

We typically don't care about numbers greater than `isize` -- our only
uses are comparisons against small constants (like `1`, `2`, `3`, etc.),
so there's no real loss of information, except in one or two rules where
we're now a little more conservative (with the worst-case being that we
don't flag, e.g., an `itertools.pairwise` that uses an extremely large
value for the slice start constant). For simplicity, a few diagnostics
now show a dedicated message when they see integers that are out of the
supported range (e.g., `outdated-version-block`).

An additional benefit here is that we get to remove a few dependencies,
especially `num-bigint`.

## Test Plan

`cargo test`

crates/ruff_python_semantic/src/analyze/typing.rs

@@ -1,14 +1,10 @@
 //! Analysis rules for the `typing` module.
 
-use num_traits::identities::Zero;
-use ruff_python_ast::{
-    self as ast, Constant, Expr, Operator, ParameterWithDefault, Parameters, Stmt,
-};
-
-use crate::analyze::type_inference::{PythonType, ResolvedPythonType};
-use crate::{Binding, BindingKind};
 use ruff_python_ast::call_path::{from_qualified_name, from_unqualified_name, CallPath};
 use ruff_python_ast::helpers::{is_const_false, map_subscript};
+use ruff_python_ast::{
+    self as ast, Constant, Expr, Int, Operator, ParameterWithDefault, Parameters, Stmt,
+};
 use ruff_python_stdlib::typing::{
     as_pep_585_generic, has_pep_585_generic, is_immutable_generic_type,
     is_immutable_non_generic_type, is_immutable_return_type, is_literal_member,
@@ -17,7 +13,9 @@ use ruff_python_stdlib::typing::{
 };
 use ruff_text_size::Ranged;
 
+use crate::analyze::type_inference::{PythonType, ResolvedPythonType};
 use crate::model::SemanticModel;
+use crate::{Binding, BindingKind};
 
 #[derive(Copy, Clone)]
 pub enum Callable {
@@ -314,14 +312,14 @@ pub fn is_type_checking_block(stmt: &ast::StmtIf, semantic: &SemanticModel) -> b
     }
 
     // Ex) `if 0:`
-    if let Expr::Constant(ast::ExprConstant {
-        value: Constant::Int(value),
-        ..
-    }) = test.as_ref()
-    {
-        if value.is_zero() {
-            return true;
-        }
+    if matches!(
+        test.as_ref(),
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Int(Int::ZERO),
+            ..
+        })
+    ) {
+        return true;
     }
 
     // Ex) `if typing.TYPE_CHECKING:`