instance method add

Adds a new error of type on attribute.

More than one error can be added to the same `attribute`.
If no `type` is supplied, `:invalid` is assumed.

```
person.errors.add(:name)
# Adds <#ActiveModel::Error attribute=name, type=invalid>
person.errors.add(:name, :not_implemented, message: "must be implemented")
# Adds <#ActiveModel::Error attribute=name, type=not_implemented,
                            options={:message=>"must be implemented"}>

person.errors.messages
# => {:name=>["is invalid", "must be implemented"]}
```

If `type` is a string, it will be used as error message.

If `type` is a symbol, it will be translated using the appropriate
scope (see `generate_message`).

```
person.errors.add(:name, :blank)
person.errors.messages
# => {:name=>["can't be blank"]}

person.errors.add(:name, :too_long, count: 25)
person.errors.messages
# => {:name=>["is too long (maximum is 25 characters)"]}
```

If `type` is a proc, it will be called, allowing for things like
`Time.now` to be used within an error.

If the `:strict` option is set to `true`, it will raise
ActiveModel::StrictValidationFailed instead of adding the error.
`:strict` option can also be set to any other exception.

```
person.errors.add(:name, :invalid, strict: true)
# => ActiveModel::StrictValidationFailed: Name is invalid
person.errors.add(:name, :invalid, strict: NameIsInvalid)
# => NameIsInvalid: Name is invalid

person.errors.messages # => {}
```

`attribute` should be set to `:base` if the error is not
directly associated with a single attribute.

```
person.errors.add(:base, :name_or_email_blank,
  message: "either name or email must be present")
person.errors.messages
# => {:base=>["either name or email must be present"]}
person.errors.details
# => {:base=>[{error: :name_or_email_blank}]}
```

: (Symbol | String, ?untyped, **untyped) -> ActiveModel::Error