So here's a few tidbits. I'm adding this here publicly so others can gain from it and contribute as well.
I'm not going to delve deeply into Arduino code here, but you have Arduino working, and you have the libraries it uses, so it's possible you can transform that into a working solution here - whether it's as effective as the Arduino or not, is yet to be seen.
The example code I've seen includes TWO libraries that duplicate some functionality or interact in some way I'm not going to try to unravel for you - but you will need to! This uses the Adafruit TFTLCD library (it also uses the Adafruit GFX library which is the core graphics components there). There's a comment about checking Adafruit_tftlcd.h for hardware definitions - over to you on that one It also uses the MCUFriend_KBV display library. The sample code that I expect you've used for the display above is the DisplayStrong.ino example. The "tft" object is created as the MCUFriend_kbv object - so there's a high likelihood you'll need to dig in to that (but also worth noting is that driver has been written to detect different displays, so likely has much more complexity than you need, assuming you have only this display). You might try simplifying an example on Arduino to only the Adafruit libraries and see if that works, as that may be a simpler place to start from - but you'll probably need to read the code.
The next thing you need to focus on is changing from Arduino pin manipulation to netmf. You'll need to dive in to the pin_magic.h code from the Adafruit lib to see how they do a lot of (fast) pin manipulation, but unfortunately that's not going to easily be achievable for what you have as the hardware capability and what netmf exposes aren't the same - you'll have to accept that you'll have to move back to more single pin manipulation via setting it to 0 and 1. But essentially, any time a pin is manipulated you need to alter that to be a netmf pin action. You'll see calls like "CS_IDLE", "CS_ACTIVE", "CD_COMMAND", "WR_IDLE", "RD_IDLE" etc, which you'll need to emulate on your assigned pins.
From there you need to see how other code (eg the ILI9341 driver) creates and manages bitmaps and fonts, and sends data to the screen and see how transportable that approach and perhaps even some of that code is for your use case.
And then eventually you could get moving towards actual coding of an app.
An alternative approach would be to look at the datasheet and command structure and start from scratch - may in fact give you quicker results. I suspect you could make a pretty quick start at the driver and send appropriate controls to prove you can get it working.
To be "full featured", you will need a decent amount of work and time, no matter where you start from. Do I still think this is possible? Yes, still possible. Will it work like the Arduino? It won't be as fast, and there's a lot of unknowns about how complex the code you have as your starting point is, and where you can best spend your effort.
One other parting thought. It's completely possible to use BOTH the Arduino and Panda in a solution that will be quicker to create, but may not meet your needs (but it's quick). You essentially write a serial-based app on the Arduino that takes graphics/text primitives from a serial stream, and writes them to the display. Then the Panda is for "higher level" functions and it sends the data to the Arduino. Without knowing anything about your end application and goals, I have no idea if that's a possible approach, or if at that point you should just say that you should just use the Arduino on it's own, but I did want to mention it in case it was a valuable option.
Code is code, you can share it where you like. But the easiest way is to host it somewhere else (even bitbucket is a reasonable dumping point) and just point people to it - if they're in a position to help, they'll head over there and look, and if uninterested they won't. I can give you one more tip in this though, if you give people your whole problem (make this display work on Panda) then you'll only get a certain level of feedback - if you come with small well defined problems (how do I do bit manipulation in C#/NETMF like this code in Arduino C++), you'll get a much more precise answer.