Las comillas están bien de la primera forma.

Aquí tienes una implementación del e-tag en php:
https://stackoverflow.com/questions/13197479/how-to-use-etags-in-a-php-file

Las cabeceras deberías cambiarlas directamente en el servidor si tienes la posibilidad.

El operador ! es el operador de negación. Algunas veces se utiliza antes de la keyword function para convertirla en una function expression. Si le añades paréntesis se produce la llamada a la función retornando true (porque las function expression llamadas de esta forma retornan undefined y el operador ! (not) retorna un booleando con el valor contrario al especificado. Es decir, si era valor positivo pasa a negativo y si era negativo pasa a positivo. Ej:
La función:
function saludar() { alert("Hola") }
Puedes crearla e invocarla con:
!function saludar() { alert("Hola") }();


La forma más frecuente de realizar esto es utilizando la sintaxis:
(function saludar() { alert("Hola") })();
Utilizando el ! se ahorra un caracter, pero esta forma de hacerlo si retorna el valor de retorno de la función. Si le sumas que puedes utilizar la sintaxis de function arrow de ES6+:
alert( (() => 5 * 5)() );
suma( (numero => numero * 5)(), 8);
suma( (numero => numero * 5)(), (otroNumero => numero * 7)() );

Suele ser bastante práctico para usar como parámetros de otras funciones, crear closures, encapsular el scope, ahorrar código...

No, tienes que configurarlo en el servidor, no en un html. Véase Apache, Nginx, Node y demás.

Tienes numerosos fallos en la función.

 El tipo del que declares la función es el tipo de dato que tiene que retornar la función. Ej:

string nombre() {
  /* haces lo que quieras con tu función */
  string nombre = "Paco";
  return nombre;
}

Para llamar a esta función desde otra, por ejemplo main solo necesitas usar el identificador y los paréntesis (no repitas el tipo que retorna la función). En este caso no tiene parámetros la función:

int main() {
  cout << nombre() << endl;
  return 0;
}

Si no quieres que se retorne nada puedes declarar la función como void:

void saludar() {
  cout << "Hola Paco" << endl;
}
 
int main() {
  saludar();
  return 0;
}

Lo usual es hacer que las funciones sean puras, esto significa que se pueda reusar para por ejemplo imprimir distintos nombres en lugar de solo saludar a paco:

void saludar(string nombre) {
  cout << "Hola " << nombre << endl;
}
 
int main() {
  string nombre1 = "Paco";
  string nombre2 = "Lucia";
  saludar(nombre1);
  saludar(nombre2);
 
  return 0;
}

Para que pueden ser útiles las funciones que retornan un tipo? Por ejemplo para unir un vector (es un array que aumenta su tamaño automáticamente):

#include <string>
#include <vector>
#include <iostream>
 
using namespace std;
 
string unir(vector<string> texto, string remplazo) {
  string variableAuxiliar = "";
  for (int i = 0; i < texto.size(); ++i) {
    if (i + 1 != texto.size()) {
      variableAuxiliar += texto[i] + remplazo;
    } else {
      variableAuxiliar += texto[i];
    }
  }
  return variableAuxiliar;
}
 
int main() {
  vector<string> meses = { "enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre" };
  string mesesSeparadosPorGuiones = unir(meses, "-");
  cout << "Meses:" << mesesSeparadosPorGuiones << endl << endl;
 
  cout << "Meses separados por saltos de lineas:" << unir(meses, "\n") << endl;
  return 0;
}

Como ves la llamada a la función unir(vector, "remplazo") esremplazada por el valor que retorna. Asique puedes usarlo desde la función cout, como asignación de valor de un string o en cualquier otro lugar que tenga sentido meter un string, incluso en parámetros de otras funciones.
Entonces podrías hacer algo como:

void imprimir(string cualquierTexto) {
  cout << "El texto introducido es:" << cualquierTexto << endl;
}
 
int main() {
  string saludo = "Hola Paco";
  imprimir(saludo);
  imprimir( unir(meses, "-") );
  return 0;
}

Al poder hacer esto se puede hacer recursividad. Es decir, una llamada que retorna un tipo, si uno de los parámetros es de ese tipo, se puede llamar a si misma.
unir(otroVector, unir(meses, "-") );
Es forma de usar funciones de forma recursiva sirve para conseguir el mismo efecto que con un bucle for o un while. Busca sobre el tema si te interesa.

También hay otro tipo de funciones que se llaman lambdas que son funciones pequeñas que no hace falta que declares fuera de main. Tiene sentido utilizarlas si es para hacer algo que no vas a volver a hacer en el futuro. Puedes echarles un ojo.

No entiendo tu pregunta.

src es un atributo.
<script>, <img> son etiquetas.
script, img son elementos (en concreto elementos html).
/x.jpg es una url relativa.
https://example.com/x.jpg es una url absoluta.
En src="/x.jpg", /x.jpg es el valor del atributo src.
v0.0.1 es un query string(cadena de consulta en español, aunque nunca vi utilizar este término en español)
? es un separador para indicar el comienzo del query string en el protocolo http
El query string está compuesto de key/value pairs (en español parejas de claves (identificadores) y valores. Normalmente se utiliza tipo /x.jpg?ancho=400

Te explico como funciona añadir la version o cualquier otra cosa en la url:
Cuando tu introduces un src="example.com/miFoto.jpg" en tu código html, estás definiendo donde se encuentra el recurso.
En la fase de parseo del navegador(cuando cargas la página el navegador lee el texto (codigo html) y lo interpreta para generar la página a partir de él. Al encontrar un <img src="/miFoto.jpg"> añadirá el base url para transformar el valor del atributo src de una ruta/url relativa a una absoluta.
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
Por defecto la ruta se obtiene del método href del objeto location. (location.href)
Una vez convertido quedará <img src="https://example.com/miFoto.jpg">

En el siguiente paso que realiza el navegador se obtiene el recurso(miFoto.jpg en este caso) realizando una petición HTTP con el método GET.
La petición que hace el navegador podría ser:

GET /miFoto.jpg HTTP/1.1
Host: example.com
Accept: */*

Entonces el servidor web de example.com recive esta petición y la procesa/parsea para comprenderla y responder en consecuencia.
El servidor web pongamos de ejemplo Apache comprueba el archivo .htaccess (si existe) en la carpeta de la web, donde puede haber unas directivas tal que:

<filesMatch ".(ico|jpg|jpeg|png|gif)$">
 Header set Cache-Control "max-age=2592000, public"
</filesMatch>

Aquí se indica que se incluya una cabecera HTTP(header) en la respuesta HTTP que se le dará al navegador en caso de que el recurso solicitado exista y su nombre cumpla con lo indicado en la expresión regular. En este caso se cumplirá para una serie de archivos cuyo nombre acabe por alguna de las extensiones de la expresión.
Entonces se incluye Cache-Control: max-age=2592000, public como cabecera de respuesta.
El navegador recive la imagen en el cuerpo de la petición junto al caché control y en base a el hashea la url del recurso y lo almacena en el caché.

Cuando se vuelve a solicitar la misma imagen, el navegador comprueba si la url que se está solicitando coincide con la que está almacenada en caché. Cuando le añades el ?v0.0.1 la url no coincide, por lo que el navegador entiende que la imagen que tiene en caché no coincide con la que se está solicitando actualmente y entiende como que es una imagen distinta. Se solicita la nueva imagen y se repite todo el proceso.

El efecto de añadir ?v0.0.1 es casi el mismo que si le cambias el nombre a la imagen cada vez que la actualices.
miFoto_v0.0.1.jpg.


PD: De todas formas esto de añadir la versión es un apaño rápido. Una solución para salir del paso de forma rápida y sencilla. Está bien para algún recurso concreto o páginas muy pequeñas y con pocas actualizaciones.

Qué pasa si mañana decides hacer una remodelación de la web? Tendrás que ir url por url y archivo por archivo cambiando las versiones. Si cambias todo de forma global puede que cambies la versión de algún archivo que no ha cambiado y obligas al cliente a descargarlo de nuevo a pesar de tener copia actual en caché.

La solución correcta/recomendada/óptima, es configurar el caché según tus necesidades. Normalmente en el servidor. Como puedes ver en uno de los ejemplos, se pueden usar expresiones regulares para cambiar el caché en archivos concretos. Para el problema que tienes, que creo que es algo más de fase de desarrollo que de producción, te recomiendo configurar el caché de tu servidor como en el ejemplo que te comenté anteriormente (en otra respuesta) de Netlify. Usando el etag para que el navegador compruebe automáticamente si el archivo cambió o no (utilizando e-tag). A parte de que es una solución más robusta, también es más cómoda para ti, ya que no tienes que andar cambiando las url para nada.

Ten cuidado con los IDOR. Son bastante comunes en este tipo de funcionalidad.

Verifica que el usuario que está cambiando la contraseña esté cambiando la de su cuenta.

También deberías pedir confirmación por correo una vez se han realizado los pasos planteados. Mandas un enlace válido durante 15 mins para que pinche el usuario. Mete captcha si quieres más seguridad contra brute force.

Es también buena práctica evitar user/email enumeration.

Evita utilizar GET (te quita de 3 o 4 fallos de seguridad)

Asegúrate que la página es HTTPS.

Evita clickjacking y cors en esa página.

Comprueba que la sesión no esté expirada.

Puedes concretar en que estás interesado o cual es tu nivel actual, que es lo último que aprendiste últimamente, con que estás atrancado y demás?

Lo que tu consideras medio para algunos puede ser muy avanzado y para otros muy básico.

Depende de tu applicación, tus clientes, el uso que se haga, la frecuencia de actualización...

No hay uno "mejor". Es como preguntar si es mejor un redirect en php, uno en el servidor o uno en javascript. Lógicamente depende de la situación y blablabla.

Antes de usar cosas (como caché) lo primero es entender que es, para que sirve, que tipos hay, que ventajas tienen, como usarlos...

Después hay implementaciones concretas de cada uno.
A nivel de servidor me gusta mucho como lo hace netlify. Siempre que subes un archivo nuevo al servidor el etag cambia y el navegador descarga el nuevo archivo y lo utilizará mientras no cambie el etag.
https://www.netlify.com/blog/2017/02/23/better-living-through-caching/

Yo utilizo ese método (porque tengo varios proyectos alojados) y también utilizo Caché Api para caché 100% navegador. Hice una implementación bastante simple, sacrifico potencia a cambio de sencillez. Lo más óptimo es ajustar cada archivo según tus necesidades. Por ejemplo so tienes una página de ventas que actualizas mensualmente, puedes cachear toda la web en el navegador durante un mes. O si actualizas cada 2 minutos o de forma irregular los twetts en tu aplicación, puedes cachear toda la página menos el componente que obtiene los twitts. Archivos como imágenes, pon por ejemplo el header del foro, se podría cachear de año en año xD.

Función para cachear de forma simple: https://github.com/StringManolo/ff/blob/master/ff.js#L41

Función (service worker) para interceptar peticiones y substituir la respuesta por el archivo en caché.
https://github.com/StringManolo/ff/blob/master/cache.js

Usándolo en una web: https://github.com/StringManolo/bugWriteups/blob/master/main.js#L247

Resultado: https://bugs.stringmanolo.ga/
* Se empieza a utilizar el caché del navegador tras la primera visita. Puedes comprobar que funciona visitándo la página sin internet, ya que al cargarse desde el caché del navegador no necesita internet para funcionar.
Esto obviamente reduce los tiempos de carga de una web drásticamente al ahorrarte todo el tiempo envuelto en hacer el handshake tcp, negociar certificados, enviar petición, esperar que el servidor reciva, procese, y responda.


Por otro lado los cache proxies están orientados a ahorrar tráfico y costos a un servidor. Por ejemplo puedes crear reglas inteligentes para cachear una página durante picos de actividad. O si tienes una gran cantidad de recursos y es frecuente que una vez se utilicen que vuelvan a reutilizar en los proximos minutos. Por ejemplo en páginas de descargas donde un archivo puede pasar años sin descargarse pero un día se vuelve popular y genera miles de descargas.
https://lpic2.unix.nl/ch09s03.html

Yo fuí a ambas, pública y concertada(mitad publica y mitad privada) y no es cuestión de clases, poder adquisitivo y demás. Son ambas bastante más similares entre ellas y se alejan del concepto estereotipado. En la concertada(religiosa) había bastante más educación, libertad, recursos, tareas y normas más estrictas que en las públicas a las que fuí, que eran pésimas todas menos 1. Aclarar que soy ateo desde que tengo conciencia xD.

Esta ley es un ataque clarísimo a la libertad de enseñanza.
No te prohíbo cultivar, pero te quito las subenciones y te mueres de hambre compitiendo contra las grandes multinacionales.

Por qué no es justo que recursos públicos vayan a la concertada? El que va a la concertada paga impuestos igual que todo el mundo.

Qué bueno. Se podría haber adivinado por el charset y las respeticiones aunque los guiones bajos despistan.