TL;DR

Primarily I would sell Rust as a language which lets you get stuff done and done quickly (all kinds of stuff, including lots of stuff you might not usually be comfortable with). A language that can be written easily, read easily, and maintained easily. Safety is an important piece of evidence we use to support those statements.

Long version

This post is in response to Rust is more than safety, see also,

The above posts discuss the question of how Rust should be marketed and how its promise of safety fits in to a marketing strategy.

IMO, choosing a programming language is about productivity, nothing more, nothing less. "How quickly can I get this thing done?" (Don't misinterpret this as "how quickly can I write this code?", "this thing" includes testing, release, maintenance, and evolution into some other thing). Rust is the language that can get you that thing done quickest, in other works Rust is about productivity.

Safety (memory safety and concurrency safety in particular) are a huge part of productivity - it takes an order of magnitude more time to fix a bug that manifests at run-time vs compile-time, and another order of magnitude to fix a bug if it occurs in production, rather than testing. Memory errors (segfaults, etc.) and concurrency errors are generally trickier to debug than most, so catching these bugs earlier makes you more productive than catching many other kinds of bugs.

Here are some other aspects of Rust that make you more productive:

Cargo - a powerful and easy to use dependency manager and build system,

high quality standard libraries, and a blossoming ecosystem of other libraries,

a strong, static, expressive type system (catches errors, improves code comprehension),

ergonomic syntax,

expressive data structures,

good docs and an awesome community to help you when the docs can't,

tools like Clippy, Rustfmt, Rustdoc, GDB integration, Racer, editor integration, etc.

stealing the best idioms from functional and OO programming styles.

Caveat: can I use this language at all?

To be fair, before asking which language will be most productive you have to ask if you can use this language at all. If you are writing a kernel, you can't use a language with mandatory garbage collection. If you have a high performance requirement, you probably can't use an interpreted language. If you are targeting a specialised domain, you probably need a language with specialised library support. Rust aims to be a language that lets you do anything, and then lets you be productive doing it.