Python3 - merge sort, O(n) space efficiency
Merge is usually O(m) time, where m is the number of elements involved in the merge. Due to your insertions and deletions, it's rather O(mn), where n is the length of the entire list. That makes your whole sort O(n^2 log n) time instead of mergesort's usual O(n log n).
You call it inplace sort, which suggests it doesn't return anything, but you do return the list if it's short and you return some start/end indices otherwise. Rather inconsistent and confusing. I'd make it not return anything (other than the default None).
Your function offers to sort only a part of the list, but you don't test that.
You use quite a few rather long variable names. I'd use shorter ones, especially i and j for the main running indices.
You insert before you delete. This might require the entire list to be reallocated and take O(n) extra space if it doesn't have an extra spot overallocated. Deleting (or popping) before inserting reduces that risk and thus increases the chance that you only take O(log n) extra space.
Mergesort ought to be stable. Yours isn't, as in case of a tie, your merge prefers the right half's next value. For example, you turn [0, 0.0] into [0.0, 0].

A modified version:
def inplace_merge_sort(lst, start=0, stop=None):
    &quot;&quot;&quot;Sort lst[start:stop].&quot;&quot;&quot;

    def merge(i, j, stop):
        &quot;&quot;&quot;Merge lst[i:j] and lst[j:stop].&quot;&quot;&quot;
        while i &lt; j &lt; stop:
            if lst[j] &lt; lst[i]:
                lst.insert(i, lst.pop(j))
                j += 1
            i += 1

    if stop is None:
        stop = len(lst)

    middle = (start + stop) // 2
    if middle &gt; start:
        inplace_merge_sort(lst, start, middle)
        inplace_merge_sort(lst, middle, stop)
        merge(start, middle, stop)

Oh, I renamed end to stop, as that's what Python mostly uses, for example:
&gt;&gt;&gt; help(slice)
Help on class slice in module builtins:

class slice(object)
 |  slice(stop)
 |  slice(start, stop[, step])

&gt;&gt;&gt; help(list.index)
Help on method_descriptor:

index(self, value, start=0, stop=9223372036854775807, /)

&gt;&gt;&gt; help(range)
Help on class range in module builtins:

class range(object)
 |  range(stop) -&gt; range object
 |  range(start, stop[, step]) -&gt; range object
```