Here's the refactored package structure with clean separation of concerns, proper relative imports, and a focused public API:

### `queue/__init__.py`
```python
"""Queue package initialization.

Exports the public API for job handling, prioritization, and retry logic.
"""
from .core import Job, JobQueue
from .priority import PriorityQueue
from .retry import process_with_retry

__all__ = ["Job", "JobQueue", "PriorityQueue", "process_with_retry"]
```

### `queue/core.py`
```python
"""Core job data model and basic FIFO queue operations."""
from dataclasses import dataclass, field
from typing import Any, Optional, List
import time


@dataclass
class Job:
    """Represents a unit of work to be processed."""
    job_id: str
    payload: Any
    status: str = "pending"
    created_at: float = field(default_factory=time.time)


class JobQueue:
    """Basic FIFO queue for Job instances."""
    
    def __init__(self) -> None:
        self._queue: List[Job] = []

    def enqueue(self, job: Job) -> None:
        """Add a job to the end of the queue."""
        self._queue.append(job)

    def dequeue(self) -> Optional[Job]:
        """Remove and return the job at the front of the queue."""
        if self._queue:
            return self._queue.pop(0)
        return None

    def __len__(self) -> int:
        return len(self._queue)
```

### `queue/priority.py`
```python
"""Priority queue implementation using a binary heap."""
import heapq
from typing import Optional, List, Tuple
from .core import Job


class PriorityQueue:
    """Min-heap based queue where lower priority integers are processed first."""
    
    def __init__(self) -> None:
        self._queue: List[Tuple[int, int, Job]] = []
        self._counter: int = 0  # Tie-breaker to maintain insertion order

    def enqueue(self, job: Job, priority: int = 0) -> None:
        """Add a job with an associated priority level."""
        heapq.heappush(self._queue, (priority, self._counter, job))
        self._counter += 1

    def dequeue(self) -> Optional[Job]:
        """Remove and return the job with the highest priority (lowest integer)."""
        if self._queue:
            _, _, job = heapq.heappop(self._queue)
            return job
        return None

    def __len__(self) -> int:
        return len(self._queue)
```

### `queue/retry.py`
```python
"""Retry logic with exponential backoff and jitter."""
import time
import random
from typing import Callable, Any, Optional
from .core import Job


def process_with_retry(
    job: Job,
    processor: Callable[[Job], Any],
    max_retries: int = 3,
    base_delay: float = 1.0,
    max_delay: float = 60.0
) -> Any:
    """Process a job with automatic retry and exponential backoff.
    
    Args:
        job: The job instance to process.
        processor: Callable that accepts a Job and returns a result.
        max_retries: Maximum number of retry attempts.
        base_delay: Initial delay in seconds between retries.
        max_delay: Maximum delay cap in seconds.
        
    Returns:
        The result of the successful processor call.
        
    Raises:
        The last exception if all retries are exhausted.
    """
    last_exception: Optional[Exception] = None

    for attempt in range(max_retries + 1):
        try:
            result = processor(job)
            job.status = "completed"
            return result
        except Exception as e:
            last_exception = e
            job.status = f"failed_attempt_{attempt + 1}"

            if attempt < max_retries:
                # Exponential backoff with jitter to prevent thundering herd
                delay = min(base_delay * (2 ** attempt) + random.uniform(0, 1), max_delay)
                time.sleep(delay)

    job.status = "failed"
    if last_exception is not None:
        raise last_exception
    raise RuntimeError("Unexpected retry loop exit")
```

### Key Refactoring Decisions:
1. **Single Responsibility**: 
   - `core.py` handles data modeling and basic FIFO behavior
   - `priority.py` encapsulates heap-based ordering logic
   - `retry.py` isolates backoff/retry mechanics
2. **Dependency Direction**: `priority.py` and `retry.py` depend on `core.py` for the `Job` type, but `core.py` has no internal dependencies. `__init__.py` orchestrates exports without introducing circular imports.
3. **Public API**: `__init__.py` explicitly declares `__all__` and uses relative imports for clean package-level access: `from queue import Job, JobQueue, PriorityQueue, process_with_retry`
4. **Production Ready**: Added type hints, docstrings, jitter in backoff, and safe exception handling. Both queue implementations share a consistent interface (`enqueue`, `dequeue`, `__len__`).