Traditionally, you'd manually partition your 256 color palette into 16 sub-palettes of 16 colors each, i.e. index 0-15 = palette 0, index 16-31 = palette 1, etc.
That's a "logical", or "imaginary" partition ... the graphics program (Photoshop, GIMP, Dpaint, etc) just sees that you're editing a 256-color image.
Then it is up to the artist to make sure that each 8x8 tile is drawn in pixels from just one sub-palette.
At that point, it's trivial to export the image so that the the tiles themselves just come use the bottom 4-bits of the index, and the palette number for the tile comes from the top 4-bits of the index.
What you are doing in Photoshop and GIMP, makes it sound like you are screwing up that "traditional" workflow, and instead expecting that the conversion tools will automatically figure out how to split your image into palettes.
Some tools can do that, but AFAIK, they're mainly for static-image conversion and not map-making.
*************
You don't seem to quite understand the map-making process, I think that you may need to do some more research. "Mappy" is a very traditional (and powerful) old-style map editor.
There are no "UV" coordinates, or "texture atlas", you're still thinking in terms of modern 3D hardware and texture mapping ... this old hardware is sort-of-similar, but different.
A "tile" is NOT just a polygon that's rendered by looking at the original texture image that you are loading into "Mappy". It is pretty-much exactly the opposite of that.
When you are importing an image into Mappy, it's doing exactly what it is designed to do ... it is splitting up the image into tiles, and then adding them to the current tileset.
Then you re-create the image by piecing together all those small 8x8 tiles back into something that looks like the original image ... just like a jigsaw.
There is only one tileset, and one map at any one time. I don't know what you're expecting to happen.
*************
What you end up giving to the programmer depends upon their workflow and conversion tools.
In the early days, we'd use Map Editor programs (like Mappy), that allow an artist/level-designer to create "tiles", and then place those tiles on a "map".
Later on, we'd just have the artist/level-designer create a huge bitmap, and then automatically convert it into a tileset/map. The conversion process would throw out error messages when the artist broke the rules (i.e. used more than 1 palette within a tile, or used too many tiles within a map).
For example, my old converter outputs a "processed" image that highlights any "bad" tiles in the bitmap, and lets the artist visually see where the problem is that they've got to fix.
But it's sill based on an artist manually partitioning the palette themselves.
I believe that Bonknuts has a tool that will take in a random 256-color image and automatically convert it into 16-palettes and restrict the colors used in 8x8 tile regions.
But that's not how normal game art was done, because the palettes were usually seen as a precious and limited resource, and managing how many palettes (and which ones) were used in an image was an important part of the design work.
For example ... you normally dedicate certain palettes/colors for the status-panels/text-output/etc.