book: strengthen motivation for delegating/inheriting constructors

Delegating constructors led with a vague 'simplify the code'; now it
explains the concrete problem (duplicated init logic that a private init
function can't solve for const/reference members). Inheriting
constructors mislabeled boilerplate as 'inefficiency'; reword to the
real motivation (tedious per-constructor forwarding).

Author: changkun

book/en-us/02-usability.md

@@ -1005,8 +1005,7 @@ SFINAE is powerful but obscure to write and produces verbose error messages. C++
 
 *(since C++11)*
 
-C++11 introduces the concept of a delegate construct, which allows a constructor to call another constructor
-in a constructor in the same class, thus simplifying the code:
+A class often has several constructors that share a lot of the same initialization logic. Before C++11, the only ways to reuse that logic were to copy it into every constructor, or to extract a private init function — but the latter cannot initialize `const` members or reference members. C++11's **delegating constructors** let one constructor delegate its initialization to another constructor of the same class, removing that duplication:
 
 ```cpp
 #include <iostream>
@@ -1033,7 +1032,7 @@ int main() {
 
 *(since C++11)*
 
-In traditional C++, constructors need to pass arguments one by one if they need inheritance, which leads to inefficiency. C++11 introduces the concept of inheritance constructors using the keyword using:
+In traditional C++, if a derived class wants to reuse its base class's constructors, it must redeclare each of them and forward the arguments one by one to the base, which is tedious and error-prone. C++11 introduces inheriting constructors via the `using` keyword, letting a derived class inherit all of the base class's constructors at once:
 
 ```cpp
 #include <iostream>

book/zh-cn/02-usability.md

@@ -920,7 +920,7 @@ SFINAE 虽然强大，但写法晦涩、错误信息冗长。C++20 的 [概念 (
 
 *（C++11）*
 
-C++11 引入了委托构造的概念，这使得构造函数可以在同一个类中一个构造函数调用另一个构造函数，从而达到简化代码的目的：
+一个类往往有多个构造函数，它们之间常常包含大量重复的初始化逻辑。在 C++11 之前，要复用这些逻辑只能把代码复制进每个构造函数，或抽取一个私有的初始化函数——但后者无法用来初始化 `const` 成员和引用成员。C++11 引入的**委托构造**允许一个构造函数把初始化工作「委托」给同一个类中的另一个构造函数，从而消除这种重复：
 
 ```cpp
 #include <iostream>
@@ -947,7 +947,7 @@ int main() {
 
 *（C++11）*
 
-在传统 C++ 中，构造函数如果需要继承是需要将参数一一传递的，这将导致效率低下。C++11 利用关键字 `using` 引入了继承构造函数的概念：
+在传统 C++ 中，如果派生类想要复用基类的构造函数，必须在派生类里逐一重新声明、并把参数一一转发给基类，十分繁琐。C++11 利用关键字 `using` 引入了继承构造函数的概念，让派生类可以「一键」继承基类的全部构造函数：
 
 ```cpp
 #include <iostream>