Generic Message of Error: * You are running 32-bit Python on a 64-bit OS

### Current behavior

When importing XGBoost on macOS, I get this error:

```text
XGBoostError: XGBoost Library (libxgboost.dylib) could not be loaded.

Likely causes:
* OpenMP runtime is not installed
- vcomp140.dll or libgomp-1.dll for Windows
- libomp.dylib for Mac OSX
- libgomp.so for Linux and other UNIX-like OSes
Mac OSX users: Run `brew install libomp` to install OpenMP runtime.

* You are running 32-bit Python on a 64-bit OS
```

The message is very generic and does not help diagnose the real problem on Apple Silicon / macOS setups.

### My environment

OS / hardware:
- Mac Mini M4 (Apple Silicon)
- macOS on ARM64

Python:
```bash
python3 -c "import platform,sys; print(sys.executable); print(platform.machine()); print(platform.architecture())"
```

Output:
```text
/Library/Developer/CommandLineTools/usr/bin/python3
arm64
('64bit', '')
```

Additional architecture checks:
```bash
python3 -c "import struct; print(struct.calcsize('P') * 8)"
```
Output:
```text
64
```

```bash
python -c "import platform; print(platform.architecture())"
```
Output:
```text
64bit
```

So:
- Python is 64-bit.
- `platform.machine()` is `arm64` (Apple Silicon).
- I am **not** running 32-bit Python.

I am using `uv` with a virtual environment at:
```text
~/Downloads/MLOps-Level3/.venv
```

XGBoost is installed in:
```text
~/Downloads/MLOps-Level3/.venv/lib/python3.12/site-packages/xgboost
```

### Why this is a problem

The error message:
1. Suggests "OpenMP runtime is not installed" as the main cause, but doesn't check or report whether `libomp.dylib` is actually missing.
2. Suggests "You are running 32-bit Python on a 64-bit OS", but my Python is clearly 64-bit (`arm64`).
3. Does not tell me whether:
- `libxgboost.dylib` exists,
- its architecture matches my Python (`arm64` vs `x86_64`),
- or if there is an architecture mismatch between Python, Homebrew, and the XGBoost binary.

On Apple Silicon and Rosetta setups, architecture mismatches are a common cause of this failure, but the current message does not surface that information.

### Proposed improvement

When loading `libxgboost.dylib` fails on macOS, the error should:
1. Detect and report:
- `platform.machine()` (e.g. `arm64` vs `x86_64`),
- `platform.architecture()` (e.g. `64bit`),
- whether `libomp.dylib` is found in expected locations,
- the architecture of `libxgboost.dylib` (via `file` or `mach-o` inspection).
2. Print a more specific message, such as:
- "libomp.dylib is missing; install with `brew install libomp`"
- "Architecture mismatch: Python is arm64 but libxgboost.dylib is x86_64"
- "Architecture mismatch: Python is x86_64 but libxgboost.dylib is arm64"
- "libxgboost.dylib exists but cannot be loaded; check OpenMP runtime and architecture compatibility"

This would make it much easier for users to understand the real cause instead of guessing from a generic message.

### Suggested implementation idea

In the Python loader (e.g. `xgboost/core.py`):
- Catch the failed `dlopen` for `libxgboost.dylib`.
- Before raising `XGBoostError`, run small environment checks:
- `platform.machine()`
- `platform.architecture()`
- `ctypes.util.find_library("omp")` or check `brew --prefix libomp`
- Optionally inspect `libxgboost.dylib` architecture via `file` / `otool` / `mach-o`.
- Build a more specific error message based on those checks.

### Why this matters

- Reduces repeated support questions for a common macOS issue.
- Helps users quickly identify:
- missing `libomp`,
- architecture mismatch (ARM64 vs x86_64),
- or 32-bit Python issues.
- Makes XGBoost more user-friendly on Apple Silicon and Rosetta setups.

### Additional context

I am using:
- `uv` as the package manager.
- Python 3.12 in a `.venv` virtual environment.
- Apple Silicon (M4) Mac.

The same error message appears for many users on macOS with Apple Silicon / Rosetta / mixed Homebrew installs, but the current diagnostics do not help distinguish the real cause.

---

If you need my full traceback or more environment details, I can provide them. The main point is: the error message should be more specific and diagnostic, not just a generic list of possible causes.

Start in xgboost/core.py at the Python loader where libxgboost.dylib is opened and the generic XGBoostError is raised. Reproduce the macOS import failure, inspect the available OpenMP runtime and library architecture, and verify that the resulting message distinguishes missing libomp, architecture mismatches, and other load failures.

Written by the indexing model from the issue text.