Safe and performant actor model in D

[Per Nordlöw]

I've read up on Pony [1] and realized that it currently has a 
superior implementation of the actor model when it comes to 
combining safety, efficiency and memory management determinism 
(thread-local reference-counting GC with consensus guarantees)

What libraries do we have at our disposal in D (including 
code.dlang.org) for implementing task-based parallelism that is 
close to Pony's solution with regards to

1. @safely sending isolated (transitively unique reference to) 
messages between actors (tasks) without the need for copying. 
Vibe.d has, for instance, `makeIsolated` [2] that serves this 
purpose.

2. a task-scheduler that can move blocked tasks between threads. 
Yes, I know, this has been discussed many times before...I'm 
checking to see if there are any updates.

3. could we make such a solution GC-free by requiring immutable 
data inside isolated messages to be unique references (not 
currently implicitly shared) aswell using, for instance, 
https://dlang.org/library/std/typecons/unique.html. I'm thinking 
of a trait named something like `makeIsolatedUnshared` that 
checks these restrictions.

[1] https://www.ponylang.org/
[2] http://vibed.org/api/vibe.core.concurrency/makeIsolated

What assistance can/could we currently/in-the-future get from D's 
type-system to verify correctness of these paradigms?