[...] All cameras record RAW, however most consumer non-DSLRs automatically convert the file, in-camera to .jpg or other commonly supported format. [...]
Err. This makes no sense.
Cameras do not record any file formats. They record picture data. How the data is stored in the camera memory is completely model dependent, might be very complicated, and is completely invisible from the outside. That means the user of the camera does not need to know anything about it at all, ever.
Examples of how picture data in memory of the camera could look like:
Camera memory will be at least one address space, addressed from 0 to n-1, n being the size of the respective part of memory, and typically one address is a byte, but it could also contain larger potions of memory, such as a 24 bit value for a single pixel, or 16 or 32 bit words, or if your A/D chip generates 12 or 14 bit pixel data it could be that, or it could be 36 or 42 bit for the three colors of each pixel, etc. It could also have multiple address spaces, for example one with the 12 or 14 bit pixel data from the A/D chip, the other byte addressed for all other data. It could store pixels together, i.e. first spot for red, second for green, third for blue color of each pixel, or separately, i.e. first all red colors of the pixels, then all green, then all blue. And so on.
Very likely theres also enough space to store multiple pictures in that memory, so where pictures will be stored is dynamic, too, not at the same fixed spot. When taking a picture, the camera will somehow instruct the fotochip to store its data at some address. Or the A/D converter could write it at always the same address and the camera has to copy it first, etc. It will also, somewhere else, store all parameters of the picture it would like to keep.
All kinds of variants are possible. And nobody but the programmer of the camera has to care, because nobody else ever will have anything to do with it.
The only thing the user sees is the final result, the data file stored on the filesystem of your persistent memory stick. File formats are standardized conventions how to store data for later access on some kind of file system. These files are produced from the picture data, which, as just described, might be stored in any number of very complex ways in the camera memory.
Thus, there is no RAW file produced initially. And there is no need to ever create a RAW file if you dont need it. If you need a JPEG, you can convert the picture data in your camera memory directly into the JPEG. Or if you want RAW, you can convert the picture data into RAW. Same for any other file format. All you need is subroutines to create the respective file formats. You never need to create any other file than the one you finally want to have.
Of course its thinkable to store the data of the picture in the memory of the camera in exactly the way it will look later in the RAW file, so storing the RAW file would be just
"create a filesystem file" and "write n bytes starting from memory address m into the new file", but thats very unlikely. For example, most RAW formats are compressed, and the initial data produced by the fotochip is of course not compressed yet.
Oh, and of course you COULD solve this the way you describe, but it would be very slow. The memory on your memory card is much slower than the internal memory of your camera. Thus, if you would first write a RAW file on the memory card, then convert the RAW file into a JPEG, you would be horribly slow and end up having unacceptable performance. Another variant would be creating the RAW file in memory, i.e. without a filesystem, but just like the final file will look like in the filesystem, in memory. But that would be an unnecessary step and slow down the camera, too, though not nearly as much as the first variant. It would also not be easier, but HARDER to program.
Damn its amazing how hard it is to describe something so trivial in general terms to non-programmers. Its actually really very simple, any programmer knows any nontrivial data in memory doesnt look like the data in the datafile.