I'll suggest four 'winners' depending on category:
- Mainframe overlay frameworks of ca. 1970
- RCA's TSOS (respectively Siemens BS2000), ca. 1970 onward, offering the ability to break any single tasking user program into command line (*1) and running build-in tools like debugger or calculator.
- Xerox Alto/Star (1973 onward), as handling multiple windows/accessories wasn't made via a dedicated multitasking OS, but within the application environment. Kinda related to overlays within a framework in the early days (see #1).
- MP/M by DR, published in 1979 for 8080 machines. While conceived as a system to share a computer between several users, it became most popular with 'power' users, due the ability to detach ones terminal from a one program and attach it to another one. Or in today's words: switching between programs.
The Fine Print:
Well, questions about 'first' usually tap into a blurry picture, as the prerequisite set up by the question, seemingly clear today weren't canonized in 'the good old days'.
For example, there is no clear separation between OS, programming language and application in the Xerox Alto/LispMachine/Star series. Thus it'S hard to say if working on a letter and a spreadsheet at the same time is multitasking because of the OS, or simply two opened documents because of the application.
Adding to blur are contradicting assumptions like "... share the system and user interface with a main program. Examples include Borland Sidekick and Macintosh desk accessories". While Mac Accessories really share the desktop at the same level as the main application, Sidekick doesn't. It halts the main application, takes over the whole machine, saves the screen and acts as new main application. In the end, SideKick is a preloaded overlay which shouldn't count according to the question. isn't it?
Similar the exclusion of overlays is harsch exactly on early systems, where such techniques were the only way to archive enhanced functionality at all. Many early (real mode, single tasking) interactive mainframe systems were build as frameworks where each and every function was realized as overlay, called in (if not already present) by whatever function a user requests. After all, in 1970, when this became a thing, average mainframes had memory sizes of 32..128 KiB. Not really something to hold multiple programs all time in memory. Virtual memory, which would automate this, was, at that time, a luxury for upper end devices. Real mode systems build on that scheme existed way into the 1980s (*2). The only difference by then was that machines offered several megabytes, allowing the overlay cache to hold essentially all code at once :)
Likewise the definition of multitasking is a wide one. But is it still multitasking in the sense of the question if an OS offers parallel tasks, but a User can only access one at a time (think MP/M)?
Or more so, what about Systems where user/terminal/task assignment is fixed, but one can break a running (user) program and operate arbitrary system commands/tools? Think of such a system as being a monitor handling resources, and memory with a loaded user program being just one of them.
Last, but not least, asking explicit for 'Desk'accessories excludes everything not being a desktop computer (do tower and Laptop still count?) and/or using a desk metaphor, which would as well put SideKick out of scope, wouldn't it?
Conclusion: Like so often a question using terminology/environment from one point in time may not make much sense before that point.
*1 - No, that's not opening a (sub-)shell but falling back into the primary shell (there is only one) and using arbitrary OS commands while the user program is still loaded. Calling
CALC that way is quite similar to open SideKicks calculator on top of any application.
*2 - Wouldn't be surprised if some still do.