As far as I know, throw-away prototyping involves creation of prototypes in iterations where each prototype is discarded after one iteration. For incremental prototyping, the resources I referred to don’t state a dissimilar explanation... What exactly is the difference between the two?
Such terms are alway a little bit problematic, since they mean not more or less than what the person who wrote them down had in mind with them. For a canonical answer, one had to ask them, not some strangers from the internet.
Said that, I usually would associate a throw-away prototype with something which is probably not even build with the technology which will be used for the final product. For example, when you are going to prototype a user interface, and use a drawing program, a spreadsheet with graphical capabilities, a mock-up tool or simply pencil and paper. So it is pretty obvious that you cannot incrementally build any real software directly from this kind of prototype. Or when you are using a scripting language for implementing a "proof-of-concept" for prototyping certain algorithm, but then switch to some compiled programming language to implement a full-fledged product.
Incremental prototyping however, is something I would expect to use the same technologies as the intended product, so one can start with a small-and-simple program and incrementally add feature by feature until it becomes the end product.
The difference is in the names: "throw-away" versus "incremental."
Throw-away infers a one time prototype. This likely happens early in the product development cycle as a means to "separate the wheat from the chaffe," so to speak — a quick and cheap implementation of a final product so stakeholders can judge whether it is even worth proceeding further. The operative words being "quick" and "cheap."
An incremental prototype infers a bigger commitment. When something is incremental, it is not a one time thing. You build something, get feedback, make changes, and get more feedback until you have an acceptable product. Basically "agile development" is fancy-talk for an incremental prototype that is deployed for end users, where at some point people go, "yeah, this is good enough." And then work stops.