The announcement of systemd-timesyncd in the systemd NEWS file does a good job of explaining the differences of this tool in comparison with Chrony and tools like it. (emphasis mine):
A new "systemd-timesyncd" daemon has been added for
synchronizing the system clock across the network. It
implements an SNTP client. In contrast to NTP
implementations such as chrony or the NTP reference server
this only implements a client side, and does not bother with
the full NTP complexity, focusing only on querying time from
one remote server and synchronizing the local clock to
it. Unless you intend to serve NTP to networked clients or
want to connect to local hardware clocks this simple NTP
client should be more than appropriate for most
This setup is a common use case for most hosts in a server fleet. They will usually get synchronized from local NTP servers, which themselves get synchronized from multiple sources, possibly including hardware. systemd-timesyncd tries to provide an easy-to-use solution for that common use case.
Trying to address your specific questions:
What are the real world differences between the two in terms of accuracy?
I believe you can get higher accuracy by getting synchronization data from multiple sources, which is specifically not a supported use case for systemd-timesyncd. But when you're using it to get synchronization data from central NTP servers connected to your reliable internal network, using multiple sources isn't really that relevant and you get good accuracy from a single source.
If you're synchronizing your server from a trusted server in a local network and in the same datacenter, the difference in accuracy between NTP and SNTP will be virtually non-existent. NTP can take RTT into account and do timesmearing, but that's not that beneficial when your RTT is really small, which is the case of a fast local network and a nearby machine. You also don't need multiple sources if you can trust the one you're using.
What are the differences in efficiency?
Getting synchronization from a single source is much simpler than getting it from multiple sources, since you don't have to make decisions about which sources are better than others and possibly combine information from multiple sources. The algorithms are much simpler and will require less CPU load for the simple case.
What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?
That's addressed in the quote above, but in any case these are use cases for Chrony that are not covered by systemd-timesyncd:
- running NTP server (so that other hosts can use this host as a source for synchrnoization);
- getting NTP synchronization information from multiple sources (which is important for hosts getting that information from public servers on the Internet); and
- getting synchronization information from the local clock, which usually involves specialized hardware such as GPS devices which can get accurate time information from satellites.
These use cases require Chrony or ntpd or similar.