A solution must look like this: we have list of intervals and we must tell for a new interval which of the intervals contain it and which of the list are contained in the new interval.
A logical start will be that the list of intervals are sorted in some data structure and we need to add the new interval in its proper place.
In the general case an insertion into some sorted list can be done in time complexity $O(log n)$, when using self-balancing binary search tree for example.
I am not sure if for the general case it is possible to reach $O(1)$ time. However to beat the logarithmic time you may need to add some limitations. It is clear that for the insertion we must not use comparison. One limited solution can be done by using modified counting sort. This however will work only if we know that the interval's points are limited to positive integer values in some interval(you can enhance the solution to work for sets that are countable and finite, if you assume that you don't have infinite memory).
If we have $n=4$ the following list $(1, 8), (3, 6), (2, 3)$ and you want to add a new interval $(4, 5)$
We can order them in array with size $n$ X largest right endpoint: in the first row we place interval's IDs in the cell with the number of the start/end point. If this cell already has an ID we are using the cell in the bottom row. We can keep a counter to the fullness level of each column.
We can add the same way the new interval in $O(1)$ time and have the intervals ordered by their nesting again in constant time.
Here is some pseudo code of the operaion in the n-th step:
Input:new_interval = (x,y)
array[x][x_column_counter] = new_interval_id
array[y][y_column_counter] = new_interval_id