Il est parfois utile de regrouper du code commun à plusieurs pages (ex: entête de document, barre de menu) ou bien des fonctions utiles à plusieurs scripts, plutôt que de réécrire ce code sur chaque page qui l'utilise. Cela permet une meilleure maintenance du code et une réutilisation éventuelle pour d'autres projets.
Les pages ASP utilisent pour cela une commande SSI (Server Side Include) qui n'est pas spécifique aux pages ASP.
Il s'agit de la commande INCLUDE qui accepte deux attributs : file ou virtual.
La syntaxe est la suivante :

<!--#include file="fichier_a_inclure.ext"-->

ou bien

<!--#include virtual="/fichier_a_inclure.ext"-->

La différence entre les deux méthodes tient au fait que file va inclure le fichier fichier_a_inclure.ext à partir du répertoire dans lequel on se trouve (celui du fichier qui comporte l'instruction include) alors que virtual va inclure ce même fichier depuis la racine WEB (ie le répertoire de base de votre application WEB). Par exemple, si nous voulons inclure un fichier qui se trouve dans le sous-dossier includes du répertoire courant, qui est lui même un sous-dossier du répertoire de base, on pourra écrire de ces deux façons :

<!--#include file="includes/fichier_a_inclure.ext"-->
<!--#include virtual="/sous-dossier/includes/fichier_a_inclure.ext"-->

Notez, puisque nous parlons de pages ASP, que vous devez écrire cette instruction en dehors de tout code asp. Par exemple, ceci est faux

<%
' du code asp
<!--#include file="includes/fichier_a_inclure.ext"-->
' encore du code asp
%>

Ceci est juste

<%
' du code asp
%>
<!--#include file="includes/fichier_a_inclure.ext"-->
<%
' encore du code asp
%>

Cela tient au fait que la commande include n'est pas une instruction ASP mais SSI (que l'on retrouve par exemple dans les fichiers .shtm ou .shtml).
Par conséquent, si le code qui se trouve dans le fichier fichier_a_inclure.ext est du code ASP, ce code doit donc se trouver encadré par les balises ASP.
Notez enfin que l'extension du fichier a peu d'importance. Il est toutefois fortement conseillé de donner l'extension .asp à vos fichiers qui contiennent du code ASP sensible (comme votre chaine de connexion à votre base de données) car ainsi le code asp sera interpreté lors d'un appel direct du fichier dans le navigateur et donc invisible.

Oui et non.
Il est tout à fait possible de faire de l'inclusion dynamique, c'est à dire inclure un fichier en fonction de telle ou telle condition, mais il n'est pas possible d'utiliser pour cela l'instruction include directement.
C'est à dire que vous ne pouvez pas écrire

<%
fichier = "fichier_a_inclure.ext"
%>
<!--#include file=<%=fichier%>-->

Si vous voulez utiliser l'instruction include, il faut pour cela faire différents tests

<%
Select Case (fichier)
  Case "fichier_a_inclure_1"
%>
    <!--#include file="includes/fichier_a_inclure_1.ext"-->
<%
  Case "fichier_a_inclure_2"
%>
    <!--#include file="includes/fichier_a_inclure_2.ext"-->
<%
  Case "fichier_a_inclure_3"
%>
    <!--#include file="includes/fichier_a_inclure_3.ext"-->
<%
  Default
%>
    <!--#include file="includes/fichier_a_inclure_default.ext"-->
<%
End Select
%>

Une autre solution consiste à utiliser la méthode Execute de l'objet Server (ASP 3.0).

<%
' du code de la page en cours
fichier = "fichier_a_inclure_executer.ext"
Server.Execute (fichier)
' du code de la page en cours
%>

Le seul inconvénient de cette méthode est que les variables et fonctions définies dans le fichier appelant n'existent pas dans le fichier appelé et vice-versa. Une dernière méthode consiste à utiliser le FileSystemObject.
Un petit exemple pour bien comprendre.
Deux fichiers : appelant.asp qui est le document à afficher et appele.asp le fichier à inclure.
appelant.asp

<%
testappelant = "valeur de testappelant dans appelant.asp"
fichier = "appele.asp"
Response.Write "dans appelant.asp : testappelant = " & testappelant & "<br>"
 
' chemin absolu du fichier à appeler
fichier = Server.MapPath(fichier)
 
' création du système de fichier
Set fso = Server.CreateObject("Scripting.FileSystemObject")
 
' obtention du ficher
Set f = fso.GetFile(fichier)
 
'ouverture du fichier en lecture (1) et affectation du contenu à la variable objet contenu
Set objcontenu = f.OpenAsTextStream(1)
 
' lecture totale du contenu
code = objcontenu.ReadAll
 
' suppression des balises asp
code = Replace(code, "<"&"%", "")
code = Replace(code, "%"&">", "")
 
' exécution du code
Execute code
 
Response.Write "dans appelant.asp : testappelant = " & testappelant & "<br>"
Response.Write "dans appelant.asp : testappele = " & testappele & "<br>"
 
' appel de la procédure définie dans appele.asp
proc_appele "hello world dans appelant.asp"
%>

appele.asp

<%
Response.Write "dans appele.asp : testappelant = " & testappelant & "<br>"
 
Function proc_appele(texte)
  Response.Write "texte dans la procédure proc_appele de appele.asp = " & texte & "<br>"
End Function
 
' définition d'une variable testappele
testappele = "valeur de testappele définie dans appele.asp"
 
Response.Write "dans appele.asp : testappele = " & testappele & "<br>"
 
' appel de la procédure définie dans appele.asp
proc_appele "hello world dans appele.asp"
 
' modification de la valeur de testappelant dans appele.asp
testappelant = "valeur de testappelant modifiée dans appele.asp"
%>

Ce qui va produire la sortie suivante lorsque l'on charge le fichier appelant.asp dans le navigateur

dans appelant.asp : testappelant = valeur de testappelant dans appelant.asp
dans appele.asp : testappelant = valeur de testappelant dans appelant.asp
dans appele.asp : testappele = valeur de testappele définie dans appele.asp
texte dans la procédure proc_appele de appele.asp = hello world dans appele.asp
dans appelant.asp : testappelant = valeur de testappelant modifiée dans appele.asp
dans appelant.asp : testappele = valeur de testappele définie dans appele.asp
texte dans la procédure proc_appele de appele.asp = hello world dans appelant.asp

Alors, pour essayer de répondre précisément à cette question, il va déjà falloir définir ce qu'est une page.
Si on considère qu'une page, c'est le fichier qui est appelé dans la barre d'adresse, alors non, il n'est pas possible d'utiliser une fonction définie dans une autre page que celle actuellement dans le navigateur.
Maintenant, il est tout à fait possible que cette page soit en fait constituée de plusieurs petits bouts de script éparpillés à travers plusieurs fichiers. Dans ce cas effectivement, il s'agit d'inclure dans le script final (la page) tous ces fichiers pour reconstituer un script complet. Et c'est même généralement ce qu'il est conseillé de faire. Par exemple, une fonction qui va vérifier qu'une adresse email est valide, il y a 2 solutions : soit la définir dans le script final
unepage.asp

<%
function verifmail(mail)
' ici le code de la fonction
end function
 
'ici le code de la page
verifmail ("toto@toto.com") 'il fait appel à la fonction
' suite du code de la page
%>

Si on a besoin d'effectuer cette vérification sur une autre page, on va devoir redéfinir la fonction
uneautrepage.asp

<%
function verifmail(mail)
' ici le code de la fonction
end function
 
'ici le code de la page
verifmail ("titi@titi.com") 'il fait appel à la fonction
' suite du code de la page
%>

Si maintenant, on veut modifier le code de vérification de mail, il va falloir modifier la définition sur les 2 pages.
C'est donc pour ça que l'on fonctionne avec des fichiers séparés qui vont contenir les définitions de tes fonctions, comme ça il n'y aura qu'à inclure ces fichiers dans les pages dans lesquelles on aura besoin de telle ou telle fonction, et quand on modifie une fonction, on ne le fait qu'une fois : dans le fichier de sa définition.
L'extension que l'on donne à ce fichier séparé n'a strictement aucune importance. Par habitude, c'est l'extension .inc qui est donnée mais il est conseillé de lui donner la double extension .inc.asp, comme ça, même si ce fichier est appelé directement via la barre d'adresse, son contenu est interprété et invisible à l'utilisateur.
verifmail.inc.asp

<%
function verifmail(mail)
' ici le code de la fonction
end function
%>

page.asp

<!--#include file="verifmail.inc.asp" -->
<%
'ici le code de la page
verifmail ("titi@titi.com") 'il fait appel à la fonction
' suite du code de la page
%>

Voilà, plus d'infos sur l'inclusion elle-même ici : Comment inclure un fichier dans un fichier ASP ?