Resources for learning how to implement an embedded programmer/debugger on my custom development board?
and one area that I know nearly nothing about is programming/debugging


Then you are a LONG way from being ready to make a usb driver and interface, start with something manageable first.  Work your way up to that.

There are numerous nucleo boards, which have a debugger front end an stlink plus mbed like interface, another mcu that performs both functions.  it appears as a flash drive and you drag and drop your program on it and the debug mcu will program the target mcu with that binary and reset.  You can also use the stlink feature to do jtag like (SWD really) things.  and the stm32's have a bootloader that you pull a strap on reset or power and you can come in through the uart.  

The drag and drop is good to get you started in the basics blink the led, find a timer to blink the led at a controlled rate, use what you learned there about what oscillator you found to then program the uart, and spit characters out the, echo them later.  Basic things that end up being your debug tools later (blinking leds or spitting info out the uart).  As well as simply making a working binary.  Fortunately you dont have to learn how to download it as they make it so simple.

Learn how to use say openocd with the stlink interface to download programs into ram and perhaps have them program the flash.  Then combine your uart experience with flash programming experience to make a uart based bootloader (even though the chip has one).  

THEN take all these new tools you have learned and tackle USB, just getting it enumerated is a task itself, if you get through that then you can think about what kind of device to show up as, and then both from the operating system side and from the device side, fairly advanced stuff, but doable eventually.  You might need to buy another board by this point, the nucleos dont usually have a device usb interface, some might, some discovery boards do so you could switch to those, they dont have the mbed interface (drag and drop your binary) so you use your stlink openocd (SWD) experience to get at/into those boards.  But some of them have a device usb port so you can connect the target device to a host with usb.  or you can get one of the $1 to $2 boards on ebay from asia that have a usb connected to the device and on the other end either the SWD pins you need or both SWD and serial so you can use either swd (you already have a nucleo and discovery by this point you can use the stlink interface on the front end of those removing a set of jumpers and jumpering over to the cheap ebay board, the (some) nucleo boards are cheaper than dedicated stlink boards/devices/dongles, or use the discovery board as your stlink) or the serial bootloader, which hopefully by now you have written your own uart based host program to communicate using that protocol as unfortunately different stm32 chips support different commands and sometimes support the same commands with subtle differences. THEN you can connect the cheap ebay board to your host via usb and work on enumerating then bidirectional communication between your host software and device software, then come up with a protocol then use your on chip flashing experience to make a usb based bootloader.


  I can't seem to find any resources on the subject matter that are
  simple enough for me to understand.


Because you are not at that level yet, work your way up there.

-buy a board you can easily use existing tools to program (nucleo boards top of the list, doesnt get easier than drag and drop)
-blink an led by counting to N then toggling and count to N repeat
-blink an led with a timer
-get the uart up, spit out stuff (polled not interrupt)
-Learn how to use the SWD interface (stlink + openocd)
-Write a host side uart program to interface with the bootloader in the target, pull the boot0 pin the correct way to enable this.
-Go back to blinking using a timer, learn how to switch to the external oscillator
-Learn how to use the PLL to muliply the clocks and adjust the various clocks per the rules of the chip (for some chips the peripherals cant/wont run at the system clock speed so you need to adjust the divisors correctly, dont forget the flash wait states).
-Find/buy a chip/board with a usb capable stm32, and wire it up right, use your serial and/or SWD experience to load led blinker or uart or other programs first, to confirm you can.  The peripherals in this chip may be different than the prior stm32 chips.  No reason to assume they will be the same across all stm32 parts.  Might have to start from scratch with blinking the led, timer blinking the led, get the uart up, get the clocks up.
-Starting with the systick if you have it learn how to deal with interrupts, poll first to learn most of it, use the uart for debugging by spitting out register values.  Then eventually enable the interrupt to the core.
-Next take say a timer (not systick, not inside the arm core) and definitely using polling work that interrupt from the peripheral to the NVIC or whatever your core/chip uses, up to the edge of the core, then once you have it all figured out how to enable it, see it, and clear it, then create an ISR connect it in your vector table (already learned this with the systick one) and enable it, the isr needs to clear the interrupt.  Blinking an led is not a bad idea here.  
-And now you have a fighting chance to start with USB, just getting through enumeration will be a huge victory
-at some point, probably during SWD, learn to program the flash from a program running on the chip (in sram perhaps). 
-make your own uart based bootloader
-have to learn the host side programming, operating system dependent probably (windows knowledge may or may not apply to linux or to mac, unless perhaps if you use libusb).  
-talk between the host and device, then create a bootloader


Depending on how ambitious you are you could bang all of this out in a weekend, or it could take you a year, depends on you.  The cheap ebay boards may take weeks to arrive where the nucleo days, so you could start with basic (toolchain) tools stuff, without that you cant even use a nucleo board while you wait for the nucleo.  Bang through the other stuff for a few weeks while you wait for the cheap ebay boards (unless you get screwed like I did and ended up with nothing but a $20 hole in my pocket instead of 10 boards) or buy a discovery board for $10 and not get screwed.

Quite possible you will fry a board, so buy at least one spare, nature of the game.  

If you want to make your own debugger front end then take one board with an mcu you can program and learn to bit bang swd into another device.

You can take a completely different approach which is signficantly easier, the arduino approach.  Get an ftdi or other usb to uart device, put that in front of the bootloader uart pins on the target mcu.  Either use dtr or other uart signals or use the gpio pins ideally from not the uart port on the ftdi you are using, to connect to boot0 and reset.  Learn to program the ftdi using libftdi for example (really easy) to manipulate those gpio pins to assert boot0 the correct way and pop reset, then use the already up and running uart with a host program that talks to the bootloader and downloads your new program.  release boot0 and pop reset to run the program.  Same way the traditional arduino boards work but different uart protocol.  You can prototype this with a $1-$2 ftdi breakout board from ebay with one of the $1 to $2 ebay stm32 boards (or with any stm32, nucleo, discovery, loose part on a breakout board).