I was wondering what advantages the ontology languages of RDFS/OWL has over using a tagging/markup system (such as http://www.schema.org/) for managing and creating metadata?
Your question makes little sense as is. RDFS is a very basic schema language to express RDF constraints. OWL is more advanced schema to express a complicated ontology. They have absolutely nothing in common with XML except that they can be expressed in XML.
RDF/OWL vs XML is false alternative. In fact one of popular serialization is using XML.
So truly the question is what the advantage of using standard, W3C approved formats. Reasons are:
Overall, I don't see any reason why should you go for non-standard, non-W3C microformat.
Couldn't diagree more with ZJR's answer. It is utterly uninformed.
So in summary Semantic Web, RDF, RDFS, OWL, SPARQL and all the Semantic Web standards are very much alive and kicking. If you don't believe me, have a look at all the activity on http://www.semanticoverflow.com
RDF and OWL are established standards for encoding semantic data and their schema, on a much deeper and generic level than an ad-hoc markup.
For example, with OWL, you can define new Schema, which will be at least partially understood by other tools (because you can mix different OWL/RDF schema together). This way, you can export from one dataset different "views" of it and have everyone cooperate. Also, you can just "explore" links between objects and their properties.
With microdata, it's basically an ad-hoc, accepted set of things you can apply, not a general semantic platform.
I would like to start by noting that this answer is not written by an expert in the field. Although I'm a proponent of semantic distributed systems, I think the applications of OWL are currently limited. Although describing precisely the niche in which OWL can be applied would be beyond the scope of this answer, I might be able to bring to light some pro's and con's.
OWL is basically a language which allows the expression of semantic constructs using classification, not unlike the classes you known from OOP and constraints between classes and their instances. One could see it as a more formal and higher-order way to describe relationships you know from a relational database.
To describe and communicate this language, it needs to be serialized to a certain format. There are several formats, of which RDF is just one.
There are three different levels of OWL, allowing for increasing expressiveness, but limiting computability (eg. whether you can find a possible solution to the questions you ask the knowledgebase described by an OWL definition). These are OWL Lite, DL and Full.
The most important advantage of using OWL/RDF is the exchange of knowledge between different knowledge bases (or classification hierarchies) and creating useful inferences without having to engineer all these bases beforehand to allow them to communicate. This is done in part by defining equivalence classes. Using namespaces allows the engineer to ascertain uniqueness; a useful paradigm.
Another advantage is the ever increasing amount of inference engines and query languages. In our networked world, there is a demand for distributed knowledge exchange.
Perhaps an important disadvantage is the relative high complexity of ascertaining the computability of inferences and their space and time constraints. Eg. in OWL full you might be able to ask for inferences which cannot be proven to terminate. Thus, there is certainly a limit to the power of OWL.
OWL knowledge is discrete... there are no half-truths or believe systems. Having these would most likely make the solutions way too complex.
But the most important disadvantage to my taste is that one simply cannot find many good engineers in the field. You'll need a knowledge engineer, one or two computer scientists and a small development team to build even a small knowledge base. Therefor, it is often much cheaper and effective to just use descriptive languages such as XML schema and describe the needed semantics in a human-readable document.
For the purpose of developing future products, RDFS/OWL XML files are to be considered pretty much dead and gone.
They require too much work to express concepts that a custom built solution based on custom text formats would express better, while keeping the data more readable and editable to humans and machines alike. They add no real value and only make life a little more miserable for everybody that stumbles on them. (and has to deal with their namespace nomenclature)
There are gigantic document handling solutions based on them, though, and they were recently developed, deployed, and are in current service. They threaten to linger around for a very long time. Many programmers in the future will undoubtedly suffer from many RDF-and-OWL-inducted WTFs.
Microdata systems, (the validator-friendly version of microformats) like those described in schema.org, present instead a lot of advantages for developers, editors, and readers, alike; both human and mechanical.
RDF concepts (those worth saving) can be mapped (and are actually being explicitly mapped) over microdata representations painlessly.
Microdata items allow authors and document handling systems to enrich communication in a way that's pretty easy (as easy as CSS or DOM) to handle and customize for the reader.