TLDR: You might not want to worry too much about hinting-and-printing (maybe this is an opinion).
To answer to the question:
"But is hinting information used at all by any print devices? If so, which kind (desktop laser/inkjet/imagesetters for litho etc) and when does it make a measurable difference?":
PostScripts and printing
Simply put, font hinting is a screen preview of the postscript font with smoother edges. A postscript font itself looks like a bitmap before being rendered and that's how the rip likes it because it give a sharp clear edge (see image below) on plates. That's also really how fonts and vectors look like once printed: without any anti-aliasing.
Postscript fonts are self-contained. The hinting itself was adjusted by the typographers who created the fonts and rip has its own algorithms to adjust the font before "rasterizing" it; for example, using the font at 11.5pts instead of 12pts, the rip will make some maths to adjust the size and rendering based on the data it has, usually the 12pts data. Each platform or system actually needs to render fonts, so font are dynamic in a way. Postscript fonts deserve a lot of respect for this reason only, hours of work have been put into them in order to create such a perfect rendering.
The postscript font by itself contains 2 files per font; one for screen (display font) and one postscript for the rip system (for printing through postscript based systems).
Each postscript font comes with a file for each style also; that's also why they can be heavier than other fonts, they really contain more data. The italic for example may not work on some of them if they were not created with an italic version. The rip will only replicate a "fake italic" rendering or not at all. In theory, that font in italic simply doesn't exist to the rip. On a side note, that's why it's good to not use any artificial styling with postscript fonts (eg. using the "bold" button on a publishing software instead of using the real font "Helvetica bold".)
Postscript fonts would look ugly alone on a display because it appears "unprocessed", with big sharp pixels, similar to a bitmap (see first picture.) That's why there is an extra file in a postscript font package; it's what's called the "screen" or "display" font. Technically, the Rip doesn't need it but it's hard to verify a proof on screen without it. The hinting part on screen is handled by the screen font, and the rip uses the postscript one with its own data and the data contained in the postscript version of the font. The screen font is simply a kind of overlay low resolution font that temporarily replaces on screen the postscript font for visual reference only, it's not the one that is printed. It adds some kind of anti-aliases effect and makes the font looks smoother on screen. When you print a postscript font on a non-postscript printer (eg. most inkjets), that's why you see it in low resolution; it only uses the low resolution screen font to print.
In the end, all fonts and vectors are converted to a very high resolution bitmap when printed. In the case of postscripts, it's the Rip that does all the work of rendering the fonts with specific algorithms before "flattening" them. That's what ripping really does; it decodes the postscript mathematical data, read them and re-encode them. There's usually a part kept as raster and one for the vectors on most modern rips but ultimately all this get crush together when being output on a plate or a film. That's why I say it all get "rasterized" in the end.
TrueTypes and printing
For TryeTypes and OpenTypes, that hinting is managed by the font engine of the computers/system they're used on and the algorithms contained in the font. Then the information is sent to the Rip in a similar way vector information are transmitted. The results are more WYSIWYG in that way and the rip doesn't need to really process them any other way than a vector.
In a way, font hinting is similar to fonts as anti-aliasing is to images. Logically (Disclaimer: I haven't personally tested TrueTypes and Rip and films), the vectorized version of a TrueType vector font should be very close to what the Rip will really use to encode its own data. One way or another, the font will need to be rendered by one system or the other (yours or the printer's system), and then will be encoded to be sent as postscript.
THIS is how it really looks like at small size:
Why care about hinting for printed projects? When does it make a measurable difference?
A lot of designers confuse what they see on screen and what is being really printed, AFTER being ripped. And this question is not about screen and web, it's about the relation of hinting in the print world.
Obviously it's very hard to verify as you cannot really compare the printed version with the screen one perfectly without scanning (putting back to digital) again that print... which might cause distortion that will change the results; the same kind of issue happen for pretty much anything that needs to be converted many times from a medium to digital to a medium, and usually the last version will suffer of some distortion compared to the original one. In this case, we're talking of distortions that may be at the level of 0.05 pts or 0.001 pts and less, even less than trapping (eg. 0.144pts for example, a "fat" standard trapping)... it doesn't take many conversions to lose accuracy in this case. Personally, I think "homemade" tests in this matter cannot give reliable results.
That's why I mentioned in another comment that this could only be verified properly if done with an expensive drum scan, and maybe use a film as medium (not paper and really not using an inkjet). Small home or office scanners' quality are way too low to be reliable in this case when compared to commercial scan or drum scans. Of course there might be a noticeable difference if you compare an on-screen 4pts size font with a 4pts print... but then again, when will you ever print at this size? Even on big font you will notice a small difference. Other factors will also make the thickness of that font change slightly, such as the dot gain for example and the type of stock or print method being used.
Comparing a vectorized font with an "active font" is like comparing an active scene seen with your own eyes with a picture of a scene. The hinting on screen is something dynamic, the print or vector is not dynamic in the same way. Obviously there will be a slight difference, you can't expect to see an "active font" being rendered on screen the same way as a vector, the same way you can't expect a vector and a raster image to look the same when zooming in. When you vectorize a font, it has the similar effect to tracing a low resolution in Illustrator; the anti-alias might or might not be rendered depending on the settings.
I have personally compared many media together because that's part of the quality control process as prepress technician; you use a film and a printed proof, and simply compare them together on a light table. I can tell you there's even a slight (very very tiny) difference when comparing a film and a laser print, and even a film and the final print. So this has more to do with the Rip process and algorhytm of each machine than the font itself. Technically speaking, they should be identical everywhere when not vectorized.
So why you should care or when... well technically I think you shouldn't. Even if there is a small difference, that difference is so tiny that your design should not suffer in any way because of that extra "conversion". And the other thing is... you don't have much control on the type of RIP being used, the fonts in it, the way it processes your texts/vectors and even the trapping at this point. These things too will change the way some elements look like once printed. Actually, trapping is what you should be worried about if you are really anxious about such small details and perfect rendering. One thing for sure, even a small 3-4 pts text or anything vector based will always look sharp and "hinting" has nothing to do with the readability (or lack of) at this point. The issue is in the choice of medium, the design, the trapping and these other factors.
Now this is based on my personal experience as a prepress who worked with different old and new RIPs, different media such as papers, films and plates, the different scans, and by having seen the differences between a film vs a laser print vs a preview from the Rips vs the final results. I'm not trying to appeal to authority (I'm simply answering) but the differences are so small from screen-to-print, they're not worth being anxious about them and frankly there isn't much you can do once your data are sent to the Rip. technically speaking, the Rip seems to treat vector based fonts that are not Postscript in the same way as any vector; so I guess the vectorized version of a font is very close to what you'll ultimately get on the rip. I personally remember doing most of my observations with Postscript fonts so I cannot confirm this besides pointing out the resources explaining how TrueTypes are processed.
If a project requires the "hinting" to be printed perfectly as on screen, then the font should be changed for a thinner one and the COLORS used (because of trapping) should be the main focus. If "hinting in printing" becomes an issue, that means the designer or printer did a bad job or chose a font that could be problematic for the project.
I think this answer has some good bits when speaking of print-and-hinting, I don't really see where are the mistakes. So I undeleted it even if it got a lot of downvotes. Maybe someone who has worked on Rip systems could point out what needs to be reviewed with some explanations and I'll gladly edit it. I unfortunately cannot provide a digital example as 1) it's expensive to scan on drum, 2) there's a cost to getting a film as well and 3) I no longer have access to the equipment either.
It's not a simple question since hinting is a display related concept and printing is something totally different. So obviously, it gets very technical and maybe someone from Agfa, Unisource, Scitex or Kodak could be better at answering this with more precision and real technical data.
PS: Postscript fonts can be vector or bitmap as source says below.
Font hinting (also known as instructing) is the use of mathematical
instructions to adjust the display of an outline font so that it lines
up with a rasterized grid. At low screen resolutions, hinting is
critical for producing clear, legible text. It can be accompanied by
antialiasing and (on liquid crystal displays) subpixel rendering for
For the purpose of on-screen text display, font hinting designates
which primary pixels are interpolated to more clearly render a font.
The open-source FreeType 2 font rendering engine uses an auto-hinter when such hinting data are not present or their use is
restricted by a software patent.
Postscript fonts: A scalable font technology from Adobe that renders fonts for both the printer and the screen. PostScript fonts
come in Type 1 and Type 3 formats. Type 1 fonts use a simple,
efficient command language and are widely used, but Type 3 are not.
Type 3 fonts can use the entire PostScript language to create complex
designs, and Type 3 fonts can also be bitmaps.
source: smashingmagazine.com, wikipedia, pcmag.com/encyclopedia/term/49555/postscript-fonts