<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def intersect_one_round(candidates, intersections):
 """Perform one step of the intersection process. .. note:: This is a helper for :func:`_all_intersections` and that function has a Fortran equivalent. Checks if the bounding boxes of each pair in ``candidates`` intersect. If the bounding boxes do not intersect, the pair is discarded. Otherwise, the pair is "accepted". Then we attempt to linearize each curve in an "accepted" pair and track the overall linearization error for every curve encountered. Args: candidates (Union[list, itertools.chain]):
 An iterable of pairs of curves (or linearized curves). intersections (list):
 A list of already encountered intersections. If any intersections can be readily determined during this round of subdivision, then they will be added to this list. Returns: list: Returns a list of the next round of ``candidates``. """

    next_candidates = []
    # NOTE: In the below we replace ``isinstance(a, B)`` with
    #       ``a.__class__ is B``, which is a 3-3.5x speedup.
    for first, second in candidates:
        both_linearized = False
        if first.__class__ is Linearization:
            if second.__class__ is Linearization:
                both_linearized = True
                bbox_int = bbox_intersect(
                    first.curve.nodes, second.curve.nodes
                )
            else:
                bbox_int = bbox_line_intersect(
                    second.nodes, first.start_node, first.end_node
                )
        else:
            if second.__class__ is Linearization:
                bbox_int = bbox_line_intersect(
                    first.nodes, second.start_node, second.end_node
                )
            else:
                bbox_int = bbox_intersect(first.nodes, second.nodes)
        if bbox_int == BoxIntersectionType.DISJOINT:
            continue

        elif bbox_int == BoxIntersectionType.TANGENT and not both_linearized:
            # NOTE: Ignore tangent bounding boxes in the linearized case
            #       because ``tangent_bbox_intersection()`` assumes that both
            #       curves are not linear.
            tangent_bbox_intersection(first, second, intersections)
            continue

        if both_linearized:
            # If both ``first`` and ``second`` are linearizations, then
            # we can intersect them immediately.
            from_linearized(first, second, intersections)
            continue

        # If we haven't ``continue``-d, add the accepted pair.
        # NOTE: This may be a wasted computation, e.g. if ``first``
        #       or ``second`` occur in multiple accepted pairs (the caller
        #       only passes one pair at a time). However, in practice
        #       the number of such pairs will be small so this cost
        #       will be low.
        lin1 = six.moves.map(Linearization.from_shape, first.subdivide())
        lin2 = six.moves.map(Linearization.from_shape, second.subdivide())
        next_candidates.extend(itertools.product(lin1, lin2))
    return next_candidates