The quoted definitions of "entity" and "object" is ambiguous, we need to be more precise. A name is associated with a storage location which in turn contains a value. The value is the data. (I find it a bit odd to say the value could also be "code", but perhaps it refers to if the value is a function, which is possible.)
Scoping is how names are associated with storage locations. A name like x may refer to different storage locations in different parts of the program, but inside a single scope, the same name always refers to the same storage location.
function f() {
int x = 17; // one storage location
}
function g() {
string x = "Hello"; // a different storage location than the other x
}
But the value of a single storage location may change inside a scope (at least in languages which support destructive assignment, which is most mainstream languages).
function f() {
int x = 17;
x = 42; // the same storage location is assigned a new value
}
Static scoping means the scopes can be determined simply by looking at the code structure. Dynamic scoping means the scoping depends on which function calls which, which means the association between names and storage location are determined at runtime.
Most mainstream languages support only static scoping. I believe Common Lisp supports both static and dynamic scoping, in which case each name is either dynamically or statically scoped.
Dynamic binding (also known as late binding) can mean a few different things, but in this context it probably refers to whether the storage location for a name is located at compile-time or at runtime.
Dynamically scoped variables must by definition also be late bound, since they can refer to different storage locations during execution. But statically scoped variables can be either statically bound (like in C, Java) or late bound (like Pyton, JavaScript).
In a pure functional language (like Haskell) variables cannot change their value. This is conceptually simpler since you can think of a name as directly bound to a value in a scope. The same is the case for constants in imperative languages: In a statically bound imperative language, the compiler may skip generating storage locations for constants altogether, and instead replace all references to the name of the constant with the value itself.
