// NEW narrow operation after generated frozen Queue ownership sources.
/// # Safety
/// The backend retires the same nonclone member/binding held by its actual
/// Context/Table owners. It retains and returns the real member on any error.
/// No callback branches, unmasks IRQ, or releases a queued/running member.
pub unsafe trait QueueRetirementBackend: Backend {
    // Ok returns only the retired logical member after actual backing release;
    // it carries no physical Binding. Keeping it until the final execution
    // check permits honest quarantine without inventing a consumed owner.
    fn retire_withdrawn(
        &mut self,
        member: Self::Member,
    ) -> Result<Self::Member, (Error, Self::Member)>;
}
impl<B: QueueRetirementBackend, const N: usize> Queue<B, N> {
    pub fn os_k1060_retire_withdrawn(
        &mut self,
        member: B::Member,
    ) -> Result<(), (Error, B::Member)> {
        let execution = match self.execution() {
            Ok(e) => e,
            Err(e) => return Err((e, member)),
        };
        if execution.thread.is_some() || self.active.is_some() || self.retained.is_some() {
            return Err((Error::Busy, member));
        }
        if let Err(error) = self.audit_at(execution) {
            return Err((error, member));
        }
        let observation = match self.backend.observe(&member) {
            Ok(o) => o,
            Err(error) => return Err((error, member)),
        };
        if self
            .entries
            .iter()
            .any(|e| e.member.is_some() && e.thread == Some(observation.thread.id))
        {
            return Err((Error::Duplicate, member));
        }
        match self.backend.retire_withdrawn(member) {
            Ok(retired) => {
                if self.backend.execution() != execution {
                    self.faulted = true;
                    return Err((Error::Quarantined, retired));
                }
                Ok(())
            }
            Err((error, actual)) => {
                if error == Error::Quarantined {
                    self.faulted = true;
                }
                Err((error, actual))
            }
        }
    }
}